Jetzt lerne ich Visual C# 2012 *ISBN 978-3-8272

Inhaltsverzeichnis
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1
Ein wenig Theorie vorab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.1
1.2
1.3
Was ist ein Programm? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie wird ein Programm erstellt? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C#, IL-Code und JIT-Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3.1 Erstellung und Ausführung von C#-Programmen . . . . . . . . . . . . . . . . . . . . . 1.3.2 Vorzüge des IL-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Das .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.1 Die .NET-Initiative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.2 Die Komponenten des .NET Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.3 Framework, SDK und Bezugsquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5 Visual C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.1IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.2RAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
21
23
25
25
26
28
29
31
32
33
34
35
37
37
38
Das erste Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.1
2.2
2.3
Am Anfang steht immer ein Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1 Übung 1: Ein eigenes Projekt anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.2 Übung 2: Das Projekt speichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.3 Übung 3: Das Programm ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quelltext – der erste Kontakt! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.1Program.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.2 Form1.cs und Form1.Designer.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.3 namespace und using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programmieren in der RAD-Umgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Die RAD-Umgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.2 Komponenten aufnehmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.3 Komponenten konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.4 Ereignisse bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.5 Eigenschaften zur Laufzeit ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.6 Die Eigenschaft Name . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
40
42
42
43
44
53
57
58
58
60
63
65
66
68
7
Inhaltsverzeichnis
2.4 Was tut sich auf der Festplatte? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5 Anwendungen von außerhalb Visual C# aufrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.8Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
68
69
71
71
72
C#-Grundkurs: Daten­verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.1Konsolenanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.1.1 Das Grundgerüst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.1.2 Konsolenanwendungen in Visual C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.1.3 Konsolenanwendungen außerhalb von Visual C# ausführen . . . . . . . . . . . . . 76
3.2 Datentypen und Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.2.1 Der »Wert« der Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.2.2 Variablen bei der Definition initialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.2.3 Werte von Variablen abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.2.4 Die elementaren Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.2.5Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
3.2.6Typumwandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.2.7 C# für Pedanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
3.3 Variablen kontra Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
3.4Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
3.4.1 Die verschiedenen Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3.4.2 Verwendung der trigonometrische Methoden . . . . . . . . . . . . . . . . . . . . . . . 98
3.4.3Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
3.5 Objekte und Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
3.5.1 C# für Philosophen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
3.5.2 Klassen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
3.5.3 Mit Klassen programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
3.6Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
3.6.1 Arrays definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
3.6.2 Auf Array-Elemente zugreifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
3.6.3 Arrays initialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
3.7 Vordefinierte Klassen und Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
3.8Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3.9 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3.10Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8
Inhaltsverzeichnis
4
C#-Grundkurs: Modularisierung und Programmsteuerung . . . . . . . . . . . . . . . 121
4.1
Modularisierung durch Klassen und Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
4.1.1 Teilprobleme in Methoden implementieren I . . . . . . . . . . . . . . . . . . . . . . . . . 123
4.1.2 Teilprobleme in Methoden implementieren II . . . . . . . . . . . . . . . . . . . . . . . . 124
4.1.3 Teilprobleme in Klassen implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
4.1.4 Eigene Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.2Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.2.1 Bedingungen: if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
4.2.2 Bedingungen und boolesche Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
4.2.3 Mehrfachbedingungen: switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
4.2.4 Die Schleifen for, while und foreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
4.2.5 Schleifenvariablen und Abbruchbedingungen . . . . . . . . . . . . . . . . . . . . . . . . 141
4.2.6 Schleifen und Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
4.2.7 Zauber mit Schleifen, Zahlen und Kaninchen . . . . . . . . . . . . . . . . . . . . . . . . 143
4.2.8 Änderung des Programmflusses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
4.3 Fehlerbehandlung durch Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
4.3.1 Ausnahmen abfangen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
4.3.2 Mehrere catch-Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4.3.3 Die Ausnahme-Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
4.3.4 Eigene Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
4.4Selbstkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
4.5Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
4.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
4.7Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
5
C#-Grundkurs: OOP-Vertiefung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
5.1
Statische und nicht-statische Klassenelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
5.1.1 Nicht-statische Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
5.1.2 Statische Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
5.2Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
5.2.1 Definition von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
5.2.2 Rückgabewerte von Methoden – return . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
5.2.3Parameterübergabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
5.2.4Überladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
5.3 Zugriff und Zugriffbeschränkung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
5.3.1Gültigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
5.3.2 Lokale Variablen und Verdeckung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
5.3.3 Die Zugriffsmodifizierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
5.4Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
9
Inhaltsverzeichnis
5.5Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
5.5.1 Der grundlegende Mechanismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
5.5.2 Der Zugriffsmodifizierer protected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
5.5.3 Aufruf des Basisklassenkonstruktors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
5.5.4 Verbergen und Überschreiben geerbter Methoden . . . . . . . . . . . . . . . . . . . 186
5.6Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.8Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
6
C#-Grundkurs: OOP-Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
6.1Polymorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
6.2Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
6.2.1 ToString() überschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
6.2.2Boxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
6.3 Schnittstellen (Interfaces) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
6.3.1 Schnittstellen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
6.3.2 Schnittstellen implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
6.4Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
6.5 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
6.6Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
7
C#-Grundkurs: E/A und Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
7.1
Schreiben auf die Konsole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
7.1.1 Write(), WriteLine() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
7.1.2 Formatierte Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
7.2 Schreiben in Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
7.3 Lesen von Tastatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
7.4 Lesen aus Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
7.5Befehlszeilenargumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
7.6Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
7.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
7.8Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
8
C#-Grundkurs: Nützliche .NET-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
8.1
Datum und Uhrzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
8.1.1 Datum und Uhrzeit ermitteln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
8.1.2 Datums- und Zeitangaben manipulieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
8.1.3 Datums- und Zeitangaben ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
8.1.4 Zeitspannen messen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
8.2Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
10
Inhaltsverzeichnis
8.3
Die Auflistungsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
8.3.1Historisches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
8.3.2 Die Auflistungen im Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
8.3.3ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
8.3.4List<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
8.3.5 Dictionary<TKey, TValue> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
8.3.6Stack<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
8.4Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
8.5 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
8.6Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
9
Ein Rundgang durch Visual C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
9.1Tour-Start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
9.2 Die Projektverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
9.2.1 Vom Nutzen der Projektverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
9.2.2 Ein Projekt anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
9.2.3 Projekte speichern, schließen und öffnen . . . . . . . . . . . . . . . . . . . . . . . . . . 234
9.2.4 Mit Projekten arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
9.2.5 Projekteigenschaften festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
9.2.6Projektmappen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
9.3 Der Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
9.3.1Syntax-Hervorhebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
9.3.2 Automatische Einrückung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
9.3.3IntelliSense . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
9.3.4 Zusammenarbeit mit Compiler und Debugger . . . . . . . . . . . . . . . . . . . . . . . 246
9.3.5 Weitere Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
9.4 Der Windows Forms-Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
9.4.1 Komponenten hinzufügen und löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
9.4.2 Komponenten auswählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
9.4.3 Komponenten dimensionieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
9.4.4 Komponenten ausrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
9.4.5 Komponenten kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
9.4.6 Das Eigenschaftenfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
9.5 Der Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
9.6 Der Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
9.6.1 Fehler und Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
9.6.2 Ablauf von Debug-Sitzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
9.6.3 Vorbereitungen zum Debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
9.6.4 Programm in Debugger laden und starten . . . . . . . . . . . . . . . . . . . . . . . . . 253
9.6.5 Programm anhalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
9.6.6 Programm schrittweise ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
9.6.7 Die Debug-Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
11
Inhaltsverzeichnis
9.7Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
9.7.1 Die Online-Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
9.7.2 Die lokale Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
9.8Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
9.9Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
9.10 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
9.11Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
10 Windows-Anwendungen: Formulare und Steuerelemente . . . . . . . . . . . . . . . . . 263
10.1 Was sind Windows-Anwendungen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
10.2 Fenster, Hauptfenster und Formulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
10.2.1 Nachgefragt, was ist eigentlich ein Fenster? . . . . . . . . . . . . . . . . . . . . . . . 266
10.2.2 Das Fenster konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
10.2.3Anwendungssymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
10.3Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
10.3.1 Programmieren mit Steuerelementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
10.3.2Beschriftungsfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
10.3.3Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
10.3.4Kontrollkästchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
10.3.5 Optionsfelder und GroupBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
10.3.6Eingabefelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
10.3.7Listenfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
10.3.8Kombinationsfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
10.3.9 Weitere Steuerelemente und weitere Informationen . . . . . . . . . . . . . . . . . . . 286
10.4Ereignisbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
10.4.1 Ereignisbehandlung einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
10.4.2 Welches Ereignis soll ich abfangen und bearbeiten? . . . . . . . . . . . . . . . . . . 287
10.5Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
10.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
10.7Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
11 Windows-Anwendungen: Menüs und Symbolleisten . . . . . . . . . . . . . . . . . . . . . . 291
11.1Menüleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
11.1.1 Aufbau einer Menüleiste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
11.1.2 Ereignisbehandlung für Menüelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
11.1.3 Menüelemente konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
11.2Symbolleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
11.3Kontextmenüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
11.4Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
11.5 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
11.6Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
12
Inhaltsverzeichnis
12 Windows-Anwendungen: Dialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
12.1 Was sind Dialogfelder? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
12.2 Dialogfelder aufbauen und konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
12.3 Dialogfelder erzeugen und anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
12.4 Einstellungen aus Dialogfeldern abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
12.5Standarddialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
12.5.1Meldungsfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
12.5.2 Dateien öffnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
12.6Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
12.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
12.8Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
13 Windows-Anwendungen: Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
13.1 Das Arbeitsmaterial des Künstlers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
13.1.1 Text zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
13.1.2 Rekonstruktion von Zeichnungen – Das Paint-Ereignis . . . . . . . . . . . . . . . . . 315
13.1.3 Zeichenmethoden – Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
13.1.4 Pinsel, Stift und Schrift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
13.2 In Panels zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
13.2.1 Die Benutzeroberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
13.2.2 Die Auswahl der Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
13.2.3 Die Funktionen zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
13.3Freihandlinien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
13.3.1 Konzept für Freihandlinien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
13.3.2 Eigene Graphics-Objekte erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
13.4 Bilder anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
13.4.1 Bilder aus Bilddateien laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
13.4.2 Bilder anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
13.4.3 Ein Bildbetrachter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
13.5Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
13.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
13.7Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
14 Datenbankzugriff (ADO.NET) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
14.1 Relationale Datenbanken und SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
14.2SQL-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
14.3 Zugriff auf eine SQL Server-Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
14.3.1 Die Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
14.3.2 Die Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
13
Inhaltsverzeichnis
14.4 Zugriff auf eine Microsoft Access-Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
14.4.1 Projekt kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
14.4.2 Datenbank erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
14.4.3 Quelltext für Datenbankzugriff anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
14.5 Datenbankanwendungen mit voller Visual C#-Unterstützung . . . . . . . . . . . . . . . . . . . 350
14.6 Datenbankanwendungen in Eigenbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
14.6.1 Das Ausgangs-Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
14.6.2 Das Zusammenspiel der Datenbankklassen . . . . . . . . . . . . . . . . . . . . . . . . 353
14.6.3 Der Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
14.7Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
14.8 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
14.9Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
15Bildschirmschoner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
15.1 Was unterscheidet Bildschirmschoner von anderen Windows-Anwendungen? . . . . . . . 361
15.2 Ein Ticker als Bildschirmschoner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
15.2.1 Konfiguration des Fensters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
15.2.2 Beenden bei Mausklick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
15.2.3 Aufrufargumente auswerten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
15.2.4 Die Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
15.2.5 Den Bildschirmschoner einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
15.3Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
15.4 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
15.5Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
16 Wie geht es weiter? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Anhang A: Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
Anhang B: Die CD zum Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
B.1
B.2
Installation der Visual C# Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
Die Programmierbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
Anhang C: Unicode-Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Anhang D: Syntax-Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
D.1Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
D.2 Elementare Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
D.3Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
D.4 Formatierung mit ToString() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
D.5Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
D.6Ablaufsteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
14
Inhaltsverzeichnis
D.7Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
D.8Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
D.9Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
D.10Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
D.11Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
D.12Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
D.13Strukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
D.14Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
D.15Generika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Anhang E: Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
15
apitel,
in diesem K
Sie lernen
gt
jekt erzeu
neues Pro
•• wie ein
wird,
2 Das erste
Programm
engrundleg
sual C# die
Vi
in
ie
w
••
dowsr eines Win
de Struktu
,
s aussieht
Programm
ethode so
die Main()-M
•• warum
wichtig ist,
suung von Vi
RAD-Umgeb
•• wie die
tioniert.
al C# funk
Nachdem Sie sich im vorangehenden Kapitel soviel Theorie zu Compilern, Interpretern und .NET anhören mussten, stürzen wir uns in diesem Kapitel gleich in die Praxis und erstellen das erste C#Programm; natürlich mit Unterstützung von Visual C#! Falls Sie noch nie in C# programmiert haben,
müssen Sie deswegen jetzt keine weichen Knie bekommen. Sie werden feststellen, dass wir für die
erste Version des Programms keine einzige Zeile Code selbst aufsetzen müssen. Das erledigt alles
Visual C# für uns!
2.1
Am Anfang steht immer ein Projekt
Legen wir also los. Sie sitzen entspannt vor Ihrem PC und sehen hoffentlich eine Windows-Oberfläche,
beispielsweise Windows XP oder Windows Vista. Starten Sie Visual C# und warten Sie ein oder zwei
Minuten, bis auf dem Bildschirm wieder Ruhe eingekehrt ist.
Sie sehen nun die IDE der Visual C# Express Edition, die Ihnen bereits in Kapitel 1.5 kurz vorgestellt
wurde. Um in dieser IDE ein Programm zu schreiben und zu erstellen, müssen Sie für das Programm
zuerst ein Projekt anlegen.
Wozu ein Projekt?
Visual C# verwaltet Programme in Projekten. Am Anfang werden Ihre Programme meist nur aus einer
einzigen Quelltextdatei bestehen. Doch mit der Zeit werden Ihre Programme ambitionierter und umfangreicher werden. Dann beginnen Sie den Quelltext auf mehrere Dateien zu verteilen, Ressourcen
wie Bilder oder Sounddateien einzubinden und mit speziellen Optionen in die Arbeit des Compilers
einzugreifen. Um mit dieser Vielzahl von Dateien und Konfigurationsoptionen besser umgehen zu können, werden in Visual C# alle Dateien eines Programms zu einem Projekt zusammengefasst. Die Informationen über ein Projekt legt Visual C# in einer eigenen Datei ab, der Projektdatei (Endung .csproj).
39
Kapitel
2
Das erste Programm
2.1.1 Übung 1: Ein eigenes Projekt anlegen
Abbildung 2.1: Neues Projekt anlegen
1. Rufen Sie im Menü Datei den Eintrag Neues Projekt auf (oder klicken Sie in der Startseite auf den
Link Neues Projekt). Es erscheint ein Dialogfeld mit den von Visual C# bereits zur Verfügung gestellten Vorlagen.
2. Wählen Sie die von Ihnen gewünschte Vorlage – in unserem Fall wäre dies die Vorlage Windows
Forms-Anwendung. Öffnen Sie dazu links die Kategorie Vorlagen/Visual C# und wählen Sie dann
rechts die Vorlage aus.
3. Geben Sie Ihrem Projekt unten in dem Eingabefeld einen Namen (beispielsweise ErstesProjekt).
4. Klicken Sie auf die Schaltfläche Durchsuchen und wählen Sie das Verzeichnis aus, unter dem das
Projektverzeichnis angelegt werden soll.
5. Deaktivieren Sie dann noch die Option Projektmappenverzeichnis
Kapitel 9.2.6) und ...
6. ... klicken Sie zum Schluss auf OK.
40
erstellen
(mehr zu dieser Option in
Am Anfang steht immer ein Projekt
Abbildung 2.2: Das neu angelegte Projekt
Im Arbeitsbereich von Visual C# erscheint ein Register namens Form1.cs [Entwurf], das Ihr zu füllendes
Anwendungsfenster enthält.
Im Projektmappen-Explorer wird das Projekt ErstesProjekt als übergeordneter fettgedruckter Knoten
mitsamt seinen Dateien aufgeführt. Unser Projekt enthält:
• Properties (Dahinter verbergen sich Konfigurationsdateien, die weitgehend automatisch von Visual
C# verwaltet werden.)
• Verweise (Unter diesem Knoten werden die Bibliotheks-Assemblies aufgelistet, die die Anwendung
verwendet. Visual C# bindet vorsorglich gleich die wichtigsten und am häufigsten benötigten Assemblies mit ein.)
• App.config (Eine weitere Konfigurationsdatei, die von der Common Language Runtime ausgewertet wird und für uns nicht weiter von Bedeutung ist.)
• Quelltextdateien
Uns interessieren natürlich vor allem die Quelltextdateien, denn in ihnen steht der auszuführende Code.
Wenn Sie ein Projekt für eine Windows Forms-Anwendung anlegen, erzeugt Visual C# automatisch drei
.cs-Dateien und verteilt auf diese ein Codegerüst, das direkt ausgeführt und vom Entwickler beliebig
ausgebaut werden kann.
• Program.cs. In dieser Quelltextdatei steht der Start-Code, mit dem die Ausführung der Anwendung
beginnt. Die wichtigste Aufgabe dieses Codes ist es, das Hauptfenster der Anwendung zu erzeugen und die Kommunikation zwischen der Anwendung und dem Anwender (vermittelt über das
Betriebssystem, welches Maus und Tastatur überwacht) herzustellen.
41
Kapitel
2
Das erste Programm
• Form1.cs. In dieser Datei wird das Fenster der Anwendung definiert. Wenn Sie eigenen Code für
das Fenster schreiben oder hinzufügen möchten, ist diese Datei der richtige Ort.
• Form1.Designer.cs. Diese Datei, deren Knoten sich unter dem Knoten Form1.cs verbirgt, beinhaltet weiteren Code für das Fenster. Allerdings wird dieser Code vom Windows Forms-Designer von
Visual C# verwaltet. Wenn Sie wissen, was Sie tun, können Sie diesen Code auch selbst bearbeiten, aber grundsätzlich – und ganz besonders für Anfänger – gilt: Finger weg von dieser Datei!
Hinweis In der Visual C#-Programmierung werden Fenster häufig als Formulare bezeichnet. Der von
Visual C# automatisch vergebene Dateiname Form1.cs leitet sich also nicht von »Form« im Sinne von
Gestalt, sondern von »Form« als Kürzel für »Formular« ab.
Tipp Wenn Sie im Projektmappen-Explorer auf den Knoten einer Quelltextdatei, beispielsweise Program.
cs, doppelklicken, wird der zugehörige Quelltext zur Bearbeitung in den Editor geladen. Für die Datei des
Fensters (in unserem Beispiel Form1.cs) wird allerdings statt des Quelltextes eine grafische Simulation
des Fensters angezeigt. Um den zugehörigen Quelltext anzuzeigen, klicken Sie mit der rechten Maustaste in das Fenster und rufen im Kontextmenü den Befehl Code anzeigen auf. Alternativ können Sie den
Dateiknoten auch mit der rechten Maustaste anklicken und so ein Kontextmenü aufklappen, in dem Sie
einen der Befehle Öffnen oder Code anzeigen auswählen. Über die Register oberhalb des Arbeitsbereichs
können Sie schnell zwischen mehreren gleichzeitig geöffneten Dateien hin und her wechseln.
2.1.2 Übung 2: Das Projekt speichern
Während Sie an einem Projekt arbeiten, sollten Sie es hin und wieder mal komplett speichern. Alles,
was Sie dazu tun müssen, ist, den Befehl Alle speichern im Menü Datei aufzurufen (oder die Tastenkombination Ÿ+Á+S zu drücken).
7. Speichern Sie jetzt einfach einmal zur Übung das Projekt.
2.1.3 Übung 3: Das Programm ausführen
Bevor wir das Programm weiter bearbeiten, wollen wir es einmal ausführen lassen.
8. Rufen Sie zuerst im Menü Erstellen den Eintrag Projektmappe
Ï.
erstellen
auf, bzw. klicken Sie auf
Visual C# nimmt nun den Inhalt der Quelltextdateien und lässt ihn vom Compiler in IL-Code übersetzen.
Stößt der Compiler dabei auf syntaktische Fehler im Quelltext, werden diese in einem eigenen Fenster
unterhalb des Arbeitsbereichfensters angezeigt. In dem von Visual C# erstellten Codegerüst dürften
allerdings keine Fehler enthalten sein.
Wenn sich Ihr Programm problemlos kompilieren lässt, sollte unten in der Statusleiste die Meldung
»Erstellen erfolgreich« erscheinen.
42
Quelltext – der erste Kontakt!
9. Anschließend können Sie das Programm mit Debuggen/Debugging starten Í oder Debuggen/Starten
ohne Debugging Ÿ+Í ausführen.
Im Hintergrund übergibt Visual C# den kompilierten IL-Code zur Ausführung an die CLR des .NET
Frameworks. Auf Ihrem Bildschirm sollte nun ein Anwendungsfenster eingeblendet werden, das die
Titelleiste Form1 besitzt. Dies ist Ihr erstes C#-Programm!
Abbildung 2.3: Unser erstes C#-Programm
Wenn die erste Begeisterung abgeklungen ist, fällt Ihnen sicherlich auf, dass dieses Programm nicht
besonders aufregend ist. Es macht nichts und zeigt nichts an. Aber immerhin kann man schon per
Maus das Fenster schließen oder es minimieren bzw. maximieren!
Hinweis Für viele Menübefehle gibt es auch ein Symbol zum schnelleren Zugriff; zum Ausführen können
Sie beispielsweise das nach rechts gerichtete Starten-Dreieck in der Symbolleiste anklicken. Wenn Sie
auch die Befehle aus dem Erstellen-Menü über Symbole aufrufen möchten, lassen Sie die Symbolleiste
Erstellen anzeigen (Aufruf über Ansicht/Symbolleisten/Erstellen).
2.2
Quelltext – der erste Kontakt!
Bevor es weitergeht und wir das Programm aus dem vorangehenden Abschnitt mithilfe der RAD-Programmierung ein wenig ausschmücken, sollten wir es nicht versäumen, einen Blick auf den Quelltext
zu werfen, den Visual C# für uns erzeugt hat.
Bei diesem Code handelt es sich um das sogenannte Anwendungsgerüst, das Visual C# jedes Mal
anlegt, wenn Sie sich im Dialogfeld zu dem Befehl Datei/Neues projekt für eine Windows-Anwendung
entscheiden. Es ist allerdings keineswegs das einzige mögliche Anwendungsgerüst. Konsolenanwendungen, Klassenbibliotheken etc. sind beispielsweise C#-Projekte, die über eigene, anders aufgebaute
Anwendungsgerüste verfügen.
Wenn wir uns im Folgenden das von Visual C# vorgegebene Codegerüst für Windows-Anwendungen etwas näher ansehen, wollen wir uns dabei mit einigen grundlegenden Elementen der C#-Syntax vertraut
43
Stichwortverzeichnis
\ (Escape-Zeichen) 83
\a (Signalton) 83
\n (Zeilenumbruch) 83
.NET 29
.NET Framework
– Bezugsquellen 33
– Bibliotheken 32
– Common Language Runtime (CLR) 31
– JIT-Compiler 26
– Speicherverwaltung 28
– Verfügbarkeit 27, 28
– Website 27, 32
A
abstract 403
Access 348
– 2003 349
– 2010 349
ADO.NET. Siehe Datenbanken
Algorithmus 22
Animation 365
– Flackern vermeiden 367
– Ticker 365
– Zeitgeber 366
Anweisungen 93
Anwendungen. Siehe Programme
Anwendungsgerüst
– Konsolenanwendungen 74
– Windows-Anwendungen 41
Anwendungssymbole 273
– Abmaße 273
– Bildtypen 273
– einrichten 274
– erstellen 273
– Farben 273
– Grafikeditor 273
Arbeitsspeicher 78
Array (Klasse) 115
ArrayList (Klasse) 223
Arrays 113
– als Parameter 167
– definieren 113
– dynamische 223
– indizierter Zugriff 113
– initialisieren 115
– in Schleifen bearbeiten 142
– sortieren 199
– von Objekten 114, 372
Assemblies 30
Auflistungsklassen 221
– ArrayList 223
– Dictionary<T, U> 228
– List<T> 226
– Stack<T> 229
– Vergleich 222
Ausdrücke 97
Ausführungsgeschwindigkeit 26
Ausgabe 203. Siehe E/A-Ausgabe
Ausnahmen 145
– abfangen 145
– auslösen 150, 151
– Ausnahme-Objekte 150
– catch-Blöcke 146
– eigene 151
– finally-Block 347
– mehrere catch-Blöcke 149
– Parameter 150
– try-Block 146
– Typumwandlung 145
– vordefinierte Klassen 149
AutoSize (Steuerelemente) 64, 276
B
BackColor (Fenster) 60, 270
BackColor (Steuerelemente) 64
BackgroundImage (Fenster) 271
BackgroundImageLayout (Fenster) 272
Backslash-Zeichen 83
base 186, 189
Batch-Dateien 211
Befehlszeilenargumente
– auswerten 211
– Bildschirmschoner 363
– in Visual C# 239
– Konsole 211
– Leerzeichen 213
Beispiele, auf Website zum Buch 382
Benutzereingaben
– Ausnahmebehandlung 146
– Typumwandlung 91
Beschriftungsfelder 60, 276
– Größenanpassung 64, 276
– Text 64
Bezeichner 93, 106
Bibliotheken
– eigene 130
411
Stichwortverzeichnis
– .NET Framework 32
– Testanwendung 132
– verfügbar machen 133
Bilder 326
– Anwendungssymbol 273
– anzeigen 326
– Größenanpassung 272
– laden 326
Bildschirmschoner 361
– Aufrufargumente 363
– beenden 363
– Dateiendung 361
– Fenster 362
– installieren 361
– testen 362
Binärdarstellung 77
Binding (Klasse) 356
BindingNavigator (Klasse) 356, 357
BindingSource (Klasse) 353, 356
Bitmap (Klasse) 326
Bogenmaß 98
bool 81
break 144
Brush (Klasse) 318
Build-Konfigurationen 238
Button (Klasse) 65, 279
byte 81
C
C#
– Auflistungsklassen 221
– Ausführungsgeschwindigkeit 26
– Ausnahmen 145
– Compiler 25
– Datentypen 78, 81
– Ein- und Ausgabe (E/A) 203
– Generika 221, 227
– Groß- und Kleinschreibung 93
– IL-Code 25
– JIT-Compiler 26
– Klassen 101
– Kommentare 46
– Kontrollstrukturen 134
– Namespaces 116
– .NET Framework 27, 28
– Plattformunabhängigkeit 27
– Schlüsselwörter 387
– Sicherheit 28
– Speicherbereinigung 113
– Syntax-Referenz 387
– Variablen 77, 78
case 138
Casting 93
catch 146
412
char 81
CheckBox (Klasse) 280
class 102
Clear() (Graphics) 316, 324
Click-Ereignis (Button) 65, 279
Click-Ereignis (Steuerelemente) 288
Clientbereich (von Fenstern) 270
ClientSize (Fenster) 327
Close() (Fenster) 296
Close() (SqlConnection) 346
Close() (SqlDataReader) 346
ColorDialog (Klasse) 308
Color (Klasse) 270
ComboBox (Klasse) 285
CommonDialog (Klasse) 308
Common Language Runtime (CLR) 31
CompareOrdinal() (string) 85
Compare() (string) 85
CompareTo() (IComparable) 199
Compiler 22, 249
– Build-Konfigurationen 238
– csc 25
– Fehlermeldungen 51, 250
– JIT-Compiler 26
– Visual C# 33
const 94
Container
– Auflistungsklassen 221
– Komponenten 264
ContextMenuStrip (Steuerelemente) 299
continue 144
ControlBox (Fenster) 268
Control (Klasse) 275
Controls (Steuerelemente) 275, 278, 281
Convert (Klasse) 89
Copy() (TextBox) 296
Cos() (Math) 97
CreateGraphics() (Steuerelemente) 323
csc (Compiler) 25
Cut() (TextBox) 296
D
DataSet (Klasse) 350, 353, 355
Dateien
– Ausgabe in Datei 206
– Bilddateien 326
– Dateiende feststellen 213
– kopieren 377
– Lesen aus Datei 209
– öffnen 309
– Öffnen-Dialog 309
– speichern 310
– StreamReader (Klasse) 209
– StreamWriter (Klasse) 206
– Zeichencodierung 211
Datenbanken 331
– ADO.NET 358
Stichwortverzeichnis
– Assistenten für Datenquellen 350
– Datensätze 332
– Datensätze abfragen 345
– Datensätze ändern 334, 350, 352
– Datensätze durchlaufen 347, 351
– Datensätze einfügen 333, 340, 351, 357
– Datensätze löschen 334, 351, 352, 357
– Datensätze speichern 351, 352, 357
– Datensätze suchen 335
– DBMS 331
– Indizes 332
– Microsoft Access 348
– Microsoft Access 2003 349
– Microsoft Access 2010 349
– Modelle
– mit DataSet 353
– mit Reader 345
– Primärschlüssel 332
– relationale Datenbanken 332
– SELECT-Befehl 335
– SQL 333
– SQL Server 335
– Tabellen 332
– Tabellen anlegen 333
– Verbindung herstellen 344, 358
Datenbank-Explorer 336
Datentypen 78, 81
– Arrays 113
– bool 81
– byte 81
– char 81
– double 81
– float 81
– int 81
– Klassen 103
– Literale 94
– long 81
– object 194, 198
– Schnittstellen 198
– short 81
– string 85
– Strukturen 408
– Typidentifizierung 202
– Typumwandlung 89
– Wertebereiche 82
DateTime (Klasse) 215
Datum 215
– ausgeben 217
– DateTime (Klasse) 215
– ermitteln 215
– Kalender 218
– manipulieren 216
Debugger 251
– Anzeigefenster 256
– Haltepunkte 255
– optimal unterstützen 253
– Programm anhalten 254
– Programm laden 253
– Programm schrittweise ausführen 256
default 138
Dekrement 96
Dialogfelder 301
– aufbauen 302
– auswerten 306
– Charakteristika 301
– Datei öffnen-Dialog 308, 309
– Datei speichern-Dialog 308
– Druck-Dialog 308
– erzeugen 304
– Farb-Dialog 308
– Font-Dialog 308
– konfigurieren 302
– Meldungsfenster 308
– modale 305
– nicht-modale 305
– Ordner-Dialog 308
– Programmstart 311
– Rahmenstil 302
– Schaltflächen 302
– Standarddialoge 308
– Startposition 303
DialogResult (Button) 302
Dictionary<T, U> (Klasse) 228
Dispose() (Graphics) 324
Division 100
Dock (Steuerelemente) 275
double 81
DoubleBuffered (Fenster) 367
DrawEllipse() (Graphics) 316
DrawImage() (Graphics) 316, 326
DrawLine() (Graphics) 316, 317
DrawPolygon() (Graphics) 316, 317
DrawRectangle() (Graphics) 316
DrawString() (Graphics) 314, 317
DropDownStyle (ComboBox) 285
E
E/A-Ausgabe
– auf Konsole 80, 203
– formatiert 204
– Formatzeichen 205
– Genauigkeit 205
– in Dateien 206
– Platzhalter 204
– WriteLine() 203
E/A-Eingabe
– aus Datei 209
– Ausnahmebehandlung 146
– ReadLine() 208
– Typumwandlung 91
– von Tastatur 91, 208
Editor 243
– Einrückung 243
– Einzüge 262
413
Stichwortverzeichnis
– IntelliSense 244
– Syntax-Hervorhebung 243
– Zeilennummern 262
Eigenschaften 172
– berechnete 176
– get 174
– im Eigenschaftenfenster 59
– Nur-Lesen 176
– Nur-Schreiben 176
– ohne private-Feld 176
– private-Feld 174
– set 174
– zur Laufzeit ändern 66
Eigenschaftenfenster 59, 249
Einbettung 180
Eingabe 208. Siehe E/A-Eingabe
Eingabeaufforderung 76
Eingabefelder 282
– Bildlaufleisten 282
– markierter Text 282
– mehrzeilige 282
– Passwörter 283
– schreibgeschützte 282
– Text 282
– Validierung 282
– Zwischenablage 296
else 135
Enabled (Steuerelemente) 280
Endloschleifen 141
Ereignisbehandlung 286
– Auswahl eines Ereignisses 287
– Ereignisbehandlungsmethoden 286
– Ereignis-Salven 287
– Ereignisse 286
– in Visual C# 286
– Mausereignisse 287
– Menüs 295
– Parameter 288
– Symbolleisten 298
Ereignisse 65
– Behandlungsmethoden 66
– Click 65, 279, 288
– im Eigenschaftenfenster 65
– KeyDown 363
– Maustasten 322
– MouseDown 287, 363
– MouseEnter 278
– MouseLeave 278
– MouseMove 322
– MouseUp 287
Escape-Sequenzen 83
Exception (Klasse) 150, 151
ExecuteNonQuery() (SqlCommand) 345
ExecuteReader() (SqlCommand) 345
Exp() (Math) 97
414
F
Farben
– Color (Klasse) 270
– Hintergrundfarbe 270
– RGB-Farben 271
– Vordergrundfarbe 302
Fehlerbehandlung 145. Siehe Ausnahmen
Felder 50
Fenster 264, 265
– Anwendungssymbol 273
– anzeigen 266
– Clientbereich 270
– Controls-Feld 275
– Dialogfelder 301
– erzeugen 266
– Farben 270
– Form (Klasse) 265
– Größe 268
– Größe fixieren 268
– Hauptfenster 49, 266
– Hintergrundbild 271
– Hintergrundfarbe 60, 270
– in Taskleiste 269, 362
– konfigurieren 267
– maximieren 362
– Position 268
– Rahmen 269
– Rahmenstil 269
– schließen 296
– Schriftart 64
– Show() 266
– Startposition 268, 379
– Systemmenü 268
– Titel 59, 268
– Titelleiste 268
– Überlappung 269
– verbergen 311
FillEllipse() (Graphics) 317
FillPolygon() (Graphics) 317
FillRectangle() (Graphics) 317
finally 347
FlatStyle (Button) 279
float 81
FolderBrowserDialog (Klasse) 308
FontDialog (Klasse) 308
Font (Klasse) 318
Font (Steuerelemente) 64
for 139
foreach 140
ForeColor (Steuerelemente) 275, 302
FormatException 147
formatierte Ausgabe 204
Format-Menü 60
Formatzeichen 205
FormBorderStyle (Fenster) 269, 302
Form (Klasse) 265
Stichwortverzeichnis
Formulare 42. Siehe Fenster
Freihandlinien 322
FromArgb() (Color) 271
G
Garbage Collection 113
Generika 221, 227
get 174
Glossar 403
Grafik 313
– Animation 365
– Arbeitsmaterial 313
– Bilddateien 326
– Farben 271
– Freihandlinien 322
– Graphics (Klasse) 314, 316
– Graphics-Objekte selbst erzeugen 323
– Linienbreite 318
– Paint-Ereignis 313, 315
– Panel-Leinwände 319
– Pinsel (Brush) 318
– Rekonstruktion 315
– Schrift (Font) 318
– Stift (Pen) 318
– Text zeichnen 314
– Zeichenfläche 313
– Zeichenmethoden 313, 316
Graphics (Klasse) 314, 316
Graphics (PaintEventArgs) 314
Gregorianischer Kalender 218
GroupBox (Klasse) 281
Gruppenfelder 281
GUI 73. Siehe Benutzeroberflächen
Gültigkeitsbereiche 169
H
Hauptfenster 49
Height (Steuerelemente) 268
HelpButton (Fenster) 268
Hide() (Cursor) 362
Hide() (Fenster) 311
Hilfe (Visual C#) 258
I
IComparable 199
Icon 273. Siehe Anwendungssymbole
if 135
IL-Code 25
Image (Button) 279
in 141
Initialisierung
– Arrays 115
– Variablen 80
Inkrement 96
Instanzbildung 109
Instanzen. Siehe Objekte
Instanzvariablen 104, 158
int 81
Integrierte Entwicklungsumgebung (IDE) 34
IntelliSense 244
interface 198
Interfaces. Siehe Schnittstellen
internal 171
internal protected 172
Interpreter 24
InvalidCastException 202
is (Operator) 202
Items (ListBox) 283
J
JIT-Compiler 26
K
Kalender 218
Kellerautomaten 229
KeyDown-Ereignis 363
Klassen 45
– abgeleitete Klasse 54
– abstrakte 403
– Arrays 114, 115, 372
– Auflistungsklassen 221
– Ausnahme-Klassen 151
– base 186, 189
– Basisklasse 54, 177
– Basisklassenkonstruktor 184
– class 102
– Daten schützen 171
– definieren 103
– Eigenschaften 172
– Einbettung 180
– Ersatzkonstruktor 108
– Felder 50, 104
– generische 226
– Instanzen bilden 109
– Instanzvariablen 104, 158
– Klassenansicht 236
– Klassenvariablen 160
– Konstruktoren 55, 108
– Methoden 46, 105, 162
– Methoden überladen 167
– Methoden überschreiben 187
– Namespaces 116
– new (Objekterzeugung) 110
– new (Verdeckung) 186
– Object 194
– partial 55
– protected 182
– public 55
– Standardkonstruktor 108
– static 157
– this 159
– Vererbung 54, 177
– Zugriffsmodifizierer 170, 171
Klassenansicht 236
415
Stichwortverzeichnis
Klassenvariablen 160
Kombinationsfelder 285
Kommentare 46
Komponenten 37, 59
– aufnehmen 60
– ausrichten 248
– auswählen 247
– Controls-Feld 275
– Ereignisse 65
– Größe festlegen 247
– Hintergrundfarbe 64
– hinzufügen 246
– instanzieren 62
– konfigurieren 63
– kopieren 248
– löschen 246
– Name 68
– positionieren 64
– Schriftart 64
Konfiguration
– Projekte 236
– Visual C# 261
Konsole 76
Konsolenanwendungen
– Ausgaben 80, 203
– automat. Schließen verhindern 75
– Befehlszeilenargumente 211
– Benutzereingaben 91
– starten (unter Windows) 76
Konstanten 94
– const-Variablen 94
– Literale 94
– PI 100
– Strings 82
Konstruktoren 55, 108
– Basisklassenkonstruktor 184
– Ersatzkonstruktor 108
– Standardkonstruktor 108, 119
Kontextmenüs 299
Kontrollkästchen 280
– Text 280
– Zustand 280
Kontrollstrukturen 134
– Abbruchbedingungen 141
– boolesche Ausdrücke 135
– break 144
– continue 144
– else 135
– Endlosschleifen 141
– foreach-Schleife 140
– for-Schleife 139
– if 135
– Iteration abbrechen 144
– Schleifen 139
– Schleifenvariablen 139
– switch 138
– Vergleichsoperatoren 136
416
– vorzeitig abbrechen 144
– while-Schleife 140
L
Label (Klasse) 60, 276
Layout-Designer. Siehe Designer
Left (Steuerelemente) 268
Length (Array) 115
Length (string) 86
ListBox (Klasse) 283
Listenfelder 283
– Auswahl abfragen 284
– Elemente hinzufügen 283
– Elemente löschen 285
– Elemente sortieren 283
List<T> (Klasse) 226
Literale 94
Location (Steuerelemente) 268
Logarithmus 97
Log() (Math) 97
Lokale 406
long 81
M
Main() 47
Maschinencode 21
mathematische Funktionen 98
Math (Klasse) 97
Mauszeiger 362
MaximizeBox (Fenster) 268
MeasureString() (Graphics) 367
Meldungsfenster 308
Meldungsschleife 48
Memberauswahl 67
Menüs 291
– Alt-Tastenkombinationen 296
– aufbauen 291
– Elemente deaktivieren 297
– Ereignisbehandlung 295
– Kontextmenüs 299
– Menüelemente 291
– Menüleisten 291
– Systemmenü 268
– Tastaturkürzel 297
– Trennstriche 293
MenuStrip (Klasse) 291
MessageBox (Klasse) 308
Methoden 46, 105, 162
– aufrufen 111
– Datenaustausch 107
– definieren 106, 162
– lokale Variablen 107
– override 187
– Parameter 107, 163
– periodisch aufrufen 366
– return 163
– Rückgabewert 163
Stichwortverzeichnis
– Signatur 162
– statische 162
– trigonometrische 98
– überladen 167
– überschreiben 187
– virtual 187
– void 107, 163
– vorzeitig beenden 163
Microsoft Access 348
– 2003 349
– 2010 349
– auf Datenbank zugreifen 349
– Datenbank anlegen 348
MinimizeBox (Fenster) 268
Modularisierung 121
– durch Klassen 125
– durch Methoden 124
MouseClick-Ereignis 288
MouseDown-Ereignis 287, 363
MouseEnter-Ereignis 278
MouseLeave-Ereignis 278
MouseMove-Ereignis 322
MouseUp-Ereignis 287
Multiline (TextBox) 282
N
Namensgebung 93
Namespaces 116
– importieren 116
– using 116
Name (Steuerelemente) 68
NaN 147
Neue Zeile-Zeichen 83
new (Objekterzeugung) 49, 110
new (Verdeckung) 181, 186
NextDouble() (Random) 220
Next() (Random) 219
null 112
O
Object (Klasse) 194
Objekte 45
– Arrays 114, 372
– Instanzbildung 109
– Lebensdauer 113
– löschen 113
– null-Referenz 112
– Objektvariablen 112
– sortieren 199
– Speicherbelegung 110
– Zugriff auf Elemente 111
Objektorientierte Programmierung (OOP) 101
– Fehlerbehandlung mit Ausnahmen 145
– Kapselung 136
– Klassen 45, 102
– Objekte 102
– Polymorphie 191
– Schnittstellen 198
– Überladung 167
– Überschreibung 187
– Vererbung 54, 177
– Zugriffsmodifizierer 170
Objektvariablen 112
OleDbAdapter (Klasse) 353, 355
OleDbCommandBuilder (Klasse) 357
OleDbCommand (Klasse) 349
OleDbConnection (Klasse) 349
OleDbDataReader (Klasse) 349
OleDbException (Klasse) 349
OpenFileDialog (Klasse) 308, 309
Operatoren 95
– arithmetische 95
– Dekrement 96
– Division 100
– Inkrement 96
– is-Operator 202
– Modulo 373
– Priorität 97
– String-Konkatenation 85
– String-Vergleiche 85
– Typidentifizierung 202
– Typumwandlung 93
– Vergleiche 136
Optionsfelder 281
– Gruppierung 281
– Text 281
– Zustand 281
override 187
P
Paint-Ereignis 315
PaintEventArgs (Klasse) 314
Panel (Klasse) 313, 319
Parameter
– Arrays 167
– Referenztypen 163
– ref-Parameter 165
– Werttypen 163
partial 55
PasswordChar (TextBox) 283
Paste() (TextBox) 296
Peak() (StreamReader) 213
Pen (Klasse) 318
PI (Math) 100
Plattformunabhängigkeit 27
Platzhalter 204
Polymorphie 191
Potenz 97
Pow() (Math) 97
Primärschlüssel 332
PrintDialog (Klasse) 308
private 172
417
Stichwortverzeichnis
Program (Klasse) 44
Programme
– Algorithmus 22
– Arbeitsverzeichnis 239
– Assemblies 30
– ausführen 27
– Ausführungsgeschwindigkeit 26
– debuggen 251
– exe-Datei 69
– Konsolenanwendungen 73
– Main()-Methode 47
– Maschinencode 21
– Name der .exe-Datei 237
– starten (unter Windows) 69, 76
– Windows-Anwendungen 40, 263
Programmerstellung 23
– Ablauf 23
– in Visual C# 39
– ohne Visual C# 33, 37
Programmhighlights
– Aus Dateien lesen 210
– Bildbetrachter 327
– Bildschirmschoner 361
– Einarmiger Bandit 290
– Freihandlinien 322
– Funktionenplotter 319
– Höhenberechnung 99
– In Dateien schreiben 207
– Kaninchenrechner 143
– Kopieren 378
– Mehrwertsteuer 23
– Mitarbeiterverwaltung 109, 143, 190, 202
– Sparbuchverwaltung 128
– Texteditor 291, 309
– Ticker 365
Projekte 39, 233
– Abhängigkeiten 242
– anlegen 234
– auf der Festplatte 68
– ausführen 42
– Build-Konfigurationen 238
– für Bibliotheken 131
– für Konsolenanwendungen 74
– für Windows-Anwendungen 40
– Klassen hinzufügen 103
– kopieren 348
– neu anlegen 40
– öffnen 235
– Projektdatei 234
– Projekteigenschaften 237
– Projektmappen 239
– Projektverwaltung 233
– schließen 235
– speichern 42, 234
– Startprojekt 241
– testen 42
– Verweise 133, 236, 241
418
– Vorteile der Projektverwaltung 234
– Zuletzt geöffnete Projekte 262
Projektmappen 239
protected 172
public 55, 107, 171
Q
Quadratwurzel 98
QuickInfo 299
R
Radiant 98
RadioButton (Klasse) 281
Random (Klasse) 219
Rapid Application Development (RAD) 35, 58
ReadLine() (Console) 91, 208
ReadOnly (TextBox) 282
Read() (SqlDataReader) 345
ref 165, 166
Referenzen 110
Refresh() (Steuerelemente) 316
Remove() (ListBox) 285
return 163
RGB-Farben 271
Run() 48
S
SaveFileDialog (Klasse) 308
Schaltflächen 65, 279
– Bilder 279
– Click-Ereignis 65
– deaktivieren 280
– flache Darstellung 279
– für Dialogfelder 302
– Größe festlegen 279
– Titel 65, 279
Schleifen 139
Schlüsselwörter 93, 387
Schnittstellen
– definieren 198
– implementieren 199
Schriften 318
ScrollBars (TextBox) 282
Selbsttest 151
SelectedIndex (ListBox) 284
SelectedIndices (ListBox) 284
SelectedItem (ListBox) 284
SelectedItems (ListBox) 284
SelectedText (TextBox) 282
SelectionMode (ListBox) 284
set 174
short 81
ShortcutKeys (ToolStripMenuItem) 297
ShowDialog() 305
Show() (Fenster) 266, 305
ShowInTaskbar (Fenster) 269, 362
Signalton-Zeichen 83
Stichwortverzeichnis
Sin() (Math) 98
Sinus 98
Size (Steuerelemente) 268
SolidBrush (Klasse) 318
Sonderzeichen
– \n (Zeilenumbruch) 83
Sort() (Array) 199
Sorted (ListBox) 283
Sort() (ListBox) 283
Speicherbereinigung 113
Split() (string) 88
SQL 333
– CREATE TABLE 333
– DELETE 334
– INSERT 333
– SELECT 335
– UPDATE 334
SqlCommand (Klasse) 345
SqlConnection (Klasse) 345
SqlDataReader (Klasse) 345
SQL Server 335
– auf Datenbank zugreifen 342
– Datenbank anlegen 336
Sqrt() (Math) 98, 147
Stack<T> 229
Standarddialoge 308
Stapel 229
StartPosition (Dialogfelder) 303
StartPosition (Fenster) 268, 379
static 157
Steuerelemente 264, 275
– andocken 275
– Aussehen 275
– Beschriftungsfelder 60, 276
– Eigenschaften 275
– Eingabefelder 282
– einrichten 276
– Ereignisse 275
– Größe 275
– Gruppenfelder 281
– Hintergrundfarbe 270
– Kombinationsfelder 285
– Kontrollkästchen 280
– Listenfelder 283
– Methoden 275
– Optionsfelder 281
– Position 275
– Schaltflächen 65, 279
– Sonstige 286
– Vordergrundfarbe 302
Stream 408
StreamReader (Klasse) 209
StreamWriter (Klasse) 206
String (Klasse) 86
Strings 50, 82
– als Parameter 164
– Escape-Sequenzen 83
– \\ (Escape-Zeichen) 83
– in Großbuchstaben umwandeln 87
– in Kleinbuchstaben umwandeln 87
– + (Konkatenation) 85
– Konstanten 82
– kopieren 86
– Länge 86
– Literale 82
– Pixelgröße 367
– String-Klasse 85
– Tabulatoren 83
– Teilstring einfügen 87
– Teilstring ersetzen 87
– Teilstring löschen 87
– Teilstring suchen 87
– Typumwandlung 91
– umbrechen 84
– Variablen 85
– vergleichen 85
– Whitespace entfernen 88
– Zeilenumbruchzeichen 83
– zerlegen 88
Strukturen 408
Swapping 166
switch 138
Symbolleisten 297
– aufbauen 297
– Bilder 298
– Ereignisbehandlung 298
– QuickInfo 299
Syntax-Referenz 387
T
Tabulatorzeichen 83
Tan() (Math) 98, 100
Tastaturkürzel 297
Text
– Ausgabe auf Konsole 203
– Ausgabe in Datei 206, 309
– Ausgabe in Fenster 276, 282
– Bearbeiten in Fenster 282
– Einlesen über Fenster 282
– Einlesen von Datei 209, 309
– Einlesen von Konsole 208
– Pixelgröße 367
– Zeichencodierung 211
– zeichnen 313
Text (Button) 279
Text (Fenster) 59, 268
Text (Kontrollkästchen) 280
Text (TextBox) 282
TextAlign (Label) 64
TextBox (Klasse) 282
TextChanged-Ereignis 282
TextImageRelation (Button) 279
this 159
throw 151
419
Stichwortverzeichnis
Ticker 365
Tick-Ereignis (Timer) 366
Timer (Klasse) 366
TimeSpan (Klasse) 218
ToDouble() (Convert) 90, 91, 130, 145
ToInt32() (Convert) 90
ToLower() (string) 87
ToolStrip (Klasse) 297
ToolStripMenuItem (Klasse) 293
TooltipText (ToolStripButton) 299
TopMost (Fenster) 269, 362
Top (Steuerelemente) 268
ToString() (Object) 90, 195
ToUpper() (string) 87
TranslateTransform() (Graphics) 321
trigonometrische Funktionen 98
Trim() (string) 88
try 146
Typidentifizierung 202
Typumwandlung 89
– Ausnahmen 145
– Convert 89
– Division 100
– explizite 93
– implizite 92
– InvalidCastException 202
– Strings in Zahlen 91
– WriteLine() 89
– Zahlen 90, 92
U
Überladung 167
Überschreibung 187
Übung, im Internet 151
Uhrzeit 215
– ausgeben 217
– DateTime (Klasse) 215
– ermitteln 215
– manipulieren 216
Unicode 82, 385
using 116
V
Variablen 50, 78, 110
– const 94
– definieren 78
– Gültigkeitsbereich 169
– initialisieren 80
– Instanzvariablen 104, 158
– Klassenvariablen 160
– lokale 107
– Namensgebung 93
– Objektvariablen 112
– Parameter 107
– Schleifenvariablen 139
– schützen 171
– Strings 85
420
– Typumwandlung 89
– Verdeckung 169
– Wert 79
– Werte abfragen 80
– Werte zuweisen 79
– Zugriff steuern 171
Verdeckung 169
Vererbung 54, 177
– abgeleitete Klasse 177
– Basisklasse 177
– Basisklassenkonstruktor 184
– Basisklassenunterobjekte 181
– Einsatzgebiete 178
– Elemente verbergen 186
– kontra Einbettung 180
– Methoden überschreiben 187
– Object 194
– private Elemente 374
– protected 182
– Standardkonstruktor 374
– Syntax 177
– Zugriff auf überschriebene Methoden 189
– Zugriff auf verborgene Elemente 186
Vergleiche
– lexikografische 86
– Objekte von Klassen 199
– Sortieren 199
– Strings 85
virtual 187
Visible (Steuerelemente) 275
Visual C# 33
– Anwendungen testen 42
– Assistenten für Datenquellen 350
– Bibliotheken 131
– Compiler 249
– Datenbank-Explorer 336
– Debugger 251
– Editor 243
– Eigenschaftenfenster 59, 249
– Ereignisbehandlung 286
– Fenster andocken 59
– Hilfe 258
– IDE 34
– Installation 381
– Klassenansicht 236
– Konsolenanwendungen 73
– Memberauswahl 67
– Menü Format 60
– Projekte 40
– Projektverwaltung 233
– RAD-Umgebung 35, 58
– Startseite 34, 261
– Werkzeugkasten 58
– Windows-Anwendungen 40
– Windows Forms-Designer 58, 246
void 107, 163
Stichwortverzeichnis
W
Wachstumsprozesse 143
Werkzeugkasten 58
while 140
Whitespace 88
Width (Steuerelemente) 268
Windows
– Anwendungen starten 69
– Eingabeaufforderung 76
– Konsole 76
– Konsolenanwendungen starten 76
Windows-Anwendungen 263
– Anwendungssymbol 273
– beenden 296
– Bilder 326
– Bildschirmschoner 361
– Container 264
– Elemente der grafischen Oberfläche 264
– Ereignisbehandlung 265, 286
– Fenster 264, 265
– Grafik 313
– Hauptfenster 49
– Kontextmenüs 299
– Layout mit Containern 319
– Meldungsfenster 308
– Meldungsschleife 48
– Menüs 291
– Run()-Methode 48
– Steuerelemente 264, 275
– Symbolleisten 297
– Zwischenablage 296
Windows Forms-Designer 246
– Auswählen 247
– Formular laden 58
– Größe festlegen 247
– Komponenten ausrichten 248
– Komponenten einfügen 60
– Komponenten hinzufügen 246
– Komponenten konfigurieren 63
– Komponenten löschen 246
– Komponenten positionieren 64
– Kopieren 248
WindowState (Fenster) 362
Write() (Console) 195
WriteLine() (Console) 80, 89, 195, 203
Z
Zahlen
– Division 100
– NaN 147
– trigonometrische Methoden 98
– Typumwandlung 90, 92
– Zufallszahlen 219
Zeichencodierung 211
Zeichnen. Siehe Grafik
Zeilennummern 262
Zeilenumbrüche 84
Zeitgeber 366
– Ereignisbehandlungsmethode 366
– starten 366
– stoppen 366
– Zeitintervall 366
Zeitmessung 218
Zufallszahlen 219
Zugriffsmodifizierer 170, 171
– internal 171
– internal protected 172
– private 172
– protected 172, 182
– public 55, 107, 171
Zwischenablage 296
421