Einstieg in Visual C# 2005

Auf einen Blick
1 Einführung ....................................................................
17
Teil I Erste Schritte....................................................
27
2 Aufbau von C#-Programmen .........................................
29
3 Konstanten, Variablen & Datentypen ...........................
47
4 Zusammengesetzte Datentypen und Namensräume .....
81
5 Operatoren ................................................................... 101
6 Kontrollkonstrukte ....................................................... 127
Teil II Objektorientierte Programmierung mit C# ..... 153
7 Einführung in die objektorientierte Programmierung ... 155
8 Generische Klassen, Schnittstellen und statische
Klassenmitglieder ......................................................... 213
9 Strings & reguläre Ausdrücke ........................................ 245
10 Ausnahmen – Exceptions .............................................. 267
11 Überladen von Operatoren ........................................... 283
12 Delegates und Ereignisse .............................................. 291
13 Indizierer, Enumeratoren und Collections ..................... 315
14 Attribute und Metadaten .............................................. 341
15 XML-Dokumentation und Präprozessor ........................ 367
16 Threading ...................................................................... 389
Teil III Windows Forms .............................................. 423
17 Einführung .................................................................... 425
18 Steuerelemente ............................................................. 471
19 Grafik und Drucken in Windows FormsAnwendungen ............................................................... 505
20 Bibliotheken und CodeDOM ........................................ 555
A Fehlersuche in Programmen .......................................... 569
B Hilfequellen .................................................................. 579
Index ............................................................................. 583
Inhalt
1
Einführung
17
1.1
.NET ....................................................................................................................
1.1.1
Verwendung mehrerer Programmiersprachen für ein Projekt .....
1.1.2
Garbage Collection und Sicherheit .................................................
17
19
21
1.2
C# ........................................................................................................................
22
1.3
Zielgruppe .........................................................................................................
23
1.4
Danksagungen ..................................................................................................
23
1.5
Kontakt ..............................................................................................................
24
1.6
Aufbau des Buches ...........................................................................................
1.6.1
Anmerkungen zur verwendeten Notation .....................................
24
25
1.7
C# Version 1 oder 2? .......................................................................................
25
1.8
Einrichten einer Entwicklungsumgebung ....................................................
25
Teil I Erste Schritte
27
2
Aufbau von C#-Programmen
29
2.1
Hello, World! ....................................................................................................
2.1.1
Der Projektmappen-Explorer ...........................................................
2.1.2
Das Eigenschaftsfenster ....................................................................
2.1.3
Die Fehlerliste ....................................................................................
2.1.4
Der Texteditor ....................................................................................
29
32
33
33
33
2.2
Kommentare ......................................................................................................
2.2.1
Kommentarblöcke .............................................................................
2.2.2
Zeilenkommentare ............................................................................
35
36
37
2.3
Syntax und Semantik .......................................................................................
38
2.4
Verwendete Syntaxschreibweise ...................................................................
38
2.5
Eine kurze Einführung zum Thema »Klassen« .............................................
2.5.1
Deklaration von Klassen ...................................................................
2.5.2
Der Einsprungspunkt ........................................................................
38
39
40
2.6
Zusammenhang zwischen Klassen- & Dateiname ......................................
40
2.7
Ausgaben auf dem Bildschirm .......................................................................
2.7.1
Namensräume ....................................................................................
2.7.2
Umbruch der Ausgabe von WriteLine() ..........................................
41
41
42
Inhalt
5
2.8
Assembly ............................................................................................................
42
2.9
Zusammenfassung ............................................................................................
2.9.1
Bestandteile eines C#-Programmes .................................................
2.9.2
Zusätzliches über das .NET Framework ..........................................
2.9.3
C# Sprachelemente ...........................................................................
44
44
45
45
2.10
Übungen ............................................................................................................
46
3
Konstanten, Variablen & Datentypen
3.1
Das EVA-Prinzip ................................................................................................
47
3.2
Variablen ............................................................................................................
3.2.1
Primitive Datentypen in C# ..............................................................
3.2.2
Datentypen für ganzzahlige Werte (Menge der ganzen
Zahlen) ................................................................................................
3.2.3
Datentypen für gebrochene Werte (Menge der rationalen
Zahlen) ................................................................................................
3.2.4
Wahrheitswerte .................................................................................
3.2.5
Zeichenketten ....................................................................................
3.2.6
Namenskonventionen für Variablen ................................................
3.2.7
Deklaration von Variablen ................................................................
3.2.8
Wertzuweisung und Initialisierung von Variablen .........................
3.2.9
Ausgabe von Variableninhalten .......................................................
3.2.10 Gültigkeit von Variablen ...................................................................
48
49
3.3
Felder ..................................................................................................................
3.3.1
Deklaration und Initialisierung .........................................................
3.3.2
Zugriff und Ausgabe von Arrays: [..], foreach ................................
3.3.3
Mehrdimensionale Arrays .................................................................
3.3.4
Unregelmäßige Arrays .......................................................................
3.3.5
Speicherbereinigung ..........................................................................
68
69
70
72
73
73
3.4
Parameter der Main-Funktion ........................................................................
74
3.5
Typqualifizierer .................................................................................................
3.5.1
static ....................................................................................................
3.5.2
const ....................................................................................................
75
76
76
3.6
Einlesen von Variablenwerten über die Tastatur ........................................
76
3.7
Zusammenfassung ............................................................................................
77
3.8
Übungen ............................................................................................................
79
4
Zusammengesetzte Datentypen und
Namensräume
4.1
6
Inhalt
Strukturen ..........................................................................................................
4.1.1
Deklaration einer Struktur ................................................................
4.1.2
Eine Struktur zur Aufnahme von Adressen ....................................
4.1.3
Werte- und Verweistypen ................................................................
4.1.4
Boxing und Unboxing ........................................................................
47
50
51
52
53
53
55
56
62
67
81
81
81
84
85
89
4.2
Aufzählungen (Enumerationen) .....................................................................
4.2.1
Deklaration einer Aufzählung ..........................................................
4.2.2
Enumerationen und Zahlwerte ........................................................
4.2.3
Basistyp einer Enumeration ..............................................................
89
91
91
93
4.3
Namensräume ...................................................................................................
4.3.1
Definition eines Namensraums ........................................................
4.3.2
Die using-Klausel ...............................................................................
94
94
96
4.4
Zusammenfassung ............................................................................................
4.4.1
Strukturen ...........................................................................................
4.4.2
Enumerationen ..................................................................................
4.4.3
Namespaces .......................................................................................
97
97
98
98
4.5
Übungen ............................................................................................................
99
5
Operatoren
5.1
Operatoren in C# ............................................................................................. 101
5.2
Additive und multiplikative Operatoren ...................................................... 103
5.2.1
Addition, Subtraktion, Multiplikation und Division ...................... 103
5.2.2
Division mit Rest (Division modulo x) ............................................ 104
101
5.3
Der Zuweisungsoperator ................................................................................ 105
5.4
Primäre Operatoren .........................................................................................
5.4.1
Klammerung "()" ................................................................................
5.4.2
Memberzugriff "." .............................................................................
5.4.3
Methodenaufruf ................................................................................
5.4.4
Array-Zugriff "[ ]" ...............................................................................
5.4.5
Post-Inkrement und Post-Dekrement .............................................
5.4.6
Anlegen von Objekten – Der new-Operator .................................
5.4.7
Typ und Größe einer Variablen ........................................................
5.4.8
Geprüfte und ungeprüfte Ausführung von Operationen .............
106
106
107
107
108
108
109
111
113
5.5
Unäre Operatoren ............................................................................................
5.5.1
Vorzeichen ..........................................................................................
5.5.2
Negationen .........................................................................................
5.5.3
Pre-Inkrement und Pre-Dekrement ................................................
5.5.4
Typumwandlung ................................................................................
116
116
116
117
118
5.6
Schiebe-Operatoren ........................................................................................ 119
5.7
Relationale und Vergleichs-Operatoren ....................................................... 120
5.7.1
Vergleichsoperatoren ........................................................................ 120
5.7.2
Die Operatoren is und as ................................................................. 121
5.8
Logisches UND, ODER und EXKLUSIV ODER (XOR) ................................ 122
5.9
Bedingtes UND, ODER und EXKLUSIV ODER ............................................ 123
5.10
Bedingung ......................................................................................................... 124
5.11
Zusammenfassung ............................................................................................ 125
5.12
Übungen ............................................................................................................ 125
Inhalt
7
6
Kontrollkonstrukte
6.1
Nassi-Shneiderman .......................................................................................... 127
6.2
Schleifen .............................................................................................................
6.2.1
for ........................................................................................................
6.2.2
while ....................................................................................................
6.2.3
do-while ..............................................................................................
6.2.4
foreach ................................................................................................
6.2.5
Steuerung der Schleifenabläufe: break & continue .......................
6.3
Bedingungen (bedingte Anweisungen) ........................................................ 139
6.3.1
if ........................................................................................................... 139
6.3.2
switch-case ......................................................................................... 144
6.4
goto ..................................................................................................................... 148
6.5
Unterstützung durch die Entwicklungsumgebung ..................................... 149
6.6
Zusammenfassung ............................................................................................ 149
6.7
Übungen ............................................................................................................ 150
Teil II Objektorientierte Programmierung
mit C#
7
7.1
8
127
Einführung in die objektorientierte
Programmierung
128
129
133
136
138
138
153
155
Klassen und Objekte ........................................................................................
7.1.1
Die Klasse als programmiersprachliche Beschreibung von
realen Objekten .................................................................................
7.1.2
Objektmethoden ...............................................................................
7.1.3
Eine spezielle Methode: Der Konstruktor ......................................
7.1.4
Die Vererbungslehre in der Programmiersprache .........................
7.1.5
Gleichheit von Objekten ...................................................................
7.1.6
Überladen von Methoden ................................................................
7.1.7
Überschreiben von Methode: Virtuelle Methoden .......................
155
155
163
172
177
188
188
191
7.2
Abstrakte Klassen ............................................................................................. 194
7.2.1
Abstrakte Methoden ......................................................................... 195
7.3
Eigenschaften (Properties) ..............................................................................
7.3.1
get ........................................................................................................
7.3.2
set ........................................................................................................
7.3.3
Unterschiedliche Sichtbarkeitsstufen für Getter und Setter .........
7.3.4
Benutzung von Properties ................................................................
7.4
Klassen auf mehrere Dateien verteilen: partielle Klassen ......................... 202
7.5
Ref- & Out-Parameter von Methoden .......................................................... 203
7.5.1
Ref-Parameter .................................................................................... 203
7.5.2
Out-Parameter ................................................................................... 204
Inhalt
196
198
199
200
201
7.6
Die Speicherverwaltung von .NET ................................................................ 205
7.6.1
Finalize() und C#-Destruktoren ....................................................... 206
7.6.2
Referenzen auf Objekte während Finalisierung ............................. 208
7.7
Zusammenfassung ............................................................................................
7.7.1
Klassen ................................................................................................
7.7.2
Properties ...........................................................................................
7.7.3
Methoden ...........................................................................................
7.8
Übungen ............................................................................................................ 209
8
Generische Klassen, Schnittstellen und
statische Klassenmitglieder
208
208
209
209
213
8.1
Klassen mit Typparametern: Generische Klassen – Generics ...................
8.1.1
Anwendung auf die Klasse Stack .....................................................
8.1.2
Instanzen der Klasse Stack erstellen ................................................
8.1.3
Typparameter und Vererbung ..........................................................
8.1.4
Generische Methoden ......................................................................
213
214
216
216
217
8.2
Schnittstellen ....................................................................................................
8.2.1
Deklaration einer Schnittstelle .........................................................
8.2.2
Implementierung einer Schnittstelle ...............................................
8.2.3
Schnittstellen und Typparameter ....................................................
8.2.4
Einschränkungen für Typparameter festlegen ................................
218
218
220
222
223
8.3
Klassenmember (statische Member) ............................................................
8.3.1
Statische Methoden ..........................................................................
8.3.2
Statische Daten ..................................................................................
8.3.3
Statische Eigenschaften .....................................................................
8.3.4
Statische Daten in nicht-statischen Methoden ..............................
8.3.5
Statische Klassen ................................................................................
8.3.6
Erzeugung von Objekten mit privaten Konstruktoren ..................
224
225
225
226
226
226
227
8.4
Objektorientierte Schmankerl5 in C# ...........................................................
8.4.1
Neuimplementierung einer Methode .............................................
8.4.2
sealed vor virtuellen Methoden .......................................................
8.4.3
Zugriff auf Implementierung der Basisklasse: base Teil II .............
8.4.4
Dispose(): Eine bessere Lösung als Finalize() .................................
228
228
233
233
236
8.5
Weitere Elemente der Unified Modelling Language ................................. 237
8.5.1
Schnittstellen ...................................................................................... 237
8.5.2
Assoziationen ..................................................................................... 238
8.6
Unterstützung durch die Entwicklungsumgebung ..................................... 239
8.7
Zusammenfassung ............................................................................................
8.7.1
Generische Klassen ............................................................................
8.7.2
Schnittstellen ......................................................................................
8.7.3
Klassenmember ..................................................................................
8.7.4
Methoden und die Vererbung .........................................................
8.8
Übungen ............................................................................................................ 242
241
241
241
242
242
Inhalt
9
10
9
Strings & reguläre Ausdrücke
245
9.1
Zeichenketten ...................................................................................................
9.1.1
string vs. String ...................................................................................
9.1.2
Länge von Zeichenketten ..................................................................
9.1.3
Iteration über eine Zeichenkette .....................................................
9.1.4
Vergleich zweier Zeichenketten .......................................................
9.1.5
Untersuchung von Zeichenketten ...................................................
9.1.6
Splitting von Strings ...........................................................................
9.1.7
Zurechtschneiden von Zeichenketten .............................................
9.1.8
Groß- und Kleinschreibung ..............................................................
9.1.9
Löschen und Ersetzen von Zeichen .................................................
9.1.10 Einfügen von Zeichen ........................................................................
9.1.11 Teilstrings herauslösen ......................................................................
9.1.12 Weitere Operationen mit Strings im Überblick .............................
9.1.13 Format() ..............................................................................................
245
245
246
246
247
250
251
252
253
253
254
254
255
255
9.2
Dynamische Zeichenketten – StringBuilder .................................................
9.2.1
Instantiierung eines StringBuilder-Objektes ...................................
9.2.2
Eigenschaften und Methoden ..........................................................
9.2.3
ToString() ............................................................................................
255
256
256
257
9.3
Reguläre Ausdrücke .........................................................................................
9.3.1
Regex: Eine Klasse für reguläre Ausdrücke .....................................
9.3.2
Grundlegender Aufbau eines regulären Ausdrucks .......................
9.3.3
Optionen .............................................................................................
259
259
260
262
9.4
Zusammenfassung ............................................................................................ 265
9.5
Übungen ............................................................................................................ 266
10
Ausnahmen – Exceptions
267
10.1
Der klassische Ansatz: Rückgabewerte ........................................................ 267
10.2
Exception-Mechanismus .................................................................................
10.2.1 Exceptions – Allgemein .....................................................................
10.2.2 Exceptions – Wie funktioniert's? .....................................................
10.2.3 Exceptions – Nachteile ......................................................................
10.2.4 Exceptions und .NET .........................................................................
269
269
269
270
271
10.3
Exceptions in C# ...............................................................................................
10.3.1 Das Werfen einer Exception ............................................................
10.3.2 Das Fangen einer Exception .............................................................
10.3.3 Member der Klasse Exception .........................................................
10.3.4 Exception-Klassen ..............................................................................
10.3.5 Eigene Exception-Klassen .................................................................
10.3.6 Aufräumarbeiten: finally ...................................................................
10.3.7 Verhaltensweisen beim Auftreten einer Ausnahme ......................
271
271
272
273
274
277
278
279
10.4
Zusammenfassung ............................................................................................ 281
10.5
Übungen ............................................................................................................ 282
Inhalt
11
Überladen von Operatoren
283
11.1
Unäre Operatoren ............................................................................................ 283
11.2
Binäre Operatoren ........................................................................................... 285
11.3
Vergleichsoperatoren ...................................................................................... 287
11.3.1 Equals() ............................................................................................... 287
11.3.2 GetHashCode() .................................................................................. 288
11.4
Einschränkungen .............................................................................................. 289
11.5
Zusammenfassung ............................................................................................ 289
11.6
Übungen ............................................................................................................ 290
12
Delegates und Ereignisse
12.1
Delegates ...........................................................................................................
12.1.1 Beispiel: Motorüberwachung ...........................................................
12.1.2 Die Deklaration eines Delegates ......................................................
12.1.3 Die Verwendung von Delegates ......................................................
12.1.4 Erstellen eines Delegates ..................................................................
12.1.5 Multicast-Delegates ..........................................................................
12.1.6 Callback-Methoden und Ausnahmen .............................................
12.1.7 Delegates und Rückgabewerte ........................................................
291
291
292
293
295
297
301
301
12.2
Ereignisse ...........................................................................................................
12.2.1 Delegate vs. Ereignis .........................................................................
12.2.2 Ereignisse: Hintergrund ....................................................................
12.2.3 Deklaration eines Ereignisses ...........................................................
12.2.4 Hinweise .............................................................................................
12.2.5 Ereignisse und Rückgabewerte ........................................................
302
302
305
305
307
309
12.3
Generische Delegates ...................................................................................... 309
12.4
Anonyme Methoden ........................................................................................ 309
12.5
Leichtere Erzeugung von Delegate-Instanzen ............................................. 310
12.6
Unterstützung durch die Entwicklungsumgebung ..................................... 311
12.7
Zusammenfassung ............................................................................................ 312
12.8
Übungen ............................................................................................................ 313
13
Indizierer, Enumeratoren und Collections
13.1
Indizierer ............................................................................................................
13.1.1 Allgemeines über Indizierer .............................................................
13.1.2 Deklaration eines Indizierers ............................................................
13.1.3 Die Verwendung eines Indizierers ...................................................
13.1.4 Indizierer mit mehreren Parametern ...............................................
291
315
315
315
315
318
320
Inhalt
11
13.2
13.3
12
Enumeratoren ....................................................................................................
13.2.1 IEnumerable und IEnumerator .........................................................
13.2.2 Ein Enumerator für BitVector64 ......................................................
13.2.3 Erweiterungen für die Unterstützung des Enumerators an
BitVector64 ........................................................................................
13.2.4 Verwendung des Enumerators .........................................................
13.2.5 Zur Perfektion fehlt noch etwas ......................................................
13.2.6 Noch einmal foreach .........................................................................
321
321
323
Collections in .NET ...........................................................................................
13.3.1 Vorwort zu Collections für .NET ab Version 2.0 ...........................
13.3.2 ArrayList ..............................................................................................
13.3.3 Queue .................................................................................................
13.3.4 Stack ....................................................................................................
13.3.5 Hashtable ............................................................................................
330
331
331
333
335
337
326
327
328
330
13.4
Zusammenfassung ............................................................................................ 338
13.5
Übungen ............................................................................................................ 339
14
Attribute und Metadaten
14.1
Attribute ............................................................................................................
14.1.1 Attribute im Code platzieren ...........................................................
14.1.2 Reservierte Attribute .........................................................................
14.1.3 Globale Attribute ...............................................................................
14.1.4 Eigene Attribute entwickeln .............................................................
14.1.5 Ziele für Attribute ..............................................................................
341
342
342
349
349
352
14.2
Metadaten .........................................................................................................
14.2.1 Typinformationen zur Laufzeit ermitteln ........................................
14.2.2 Attribute auslesen ..............................................................................
14.2.3 Ausblick ...............................................................................................
353
354
362
364
341
14.3
Zusammenfassung ............................................................................................ 364
14.4
Übungen ............................................................................................................ 365
15
XML-Dokumentation und Präprozessor
15.1
XML-Dokumentation .......................................................................................
15.1.1 XML als Datenformat ........................................................................
15.1.2 Eine weitere Form des Kommentars: /// .....................................
15.1.3 Dokumentationstags .........................................................................
15.1.4 Textauszeichnung und Verweise ......................................................
15.2
Präprozessor ...................................................................................................... 381
15.2.1 Ein- und Ausblenden von Code ....................................................... 381
15.2.2 Weitere Direktiven ............................................................................ 384
367
367
367
371
372
378
15.3
Zusammenfassung ............................................................................................ 386
15.4
Übungen ............................................................................................................ 386
Inhalt
16
Threading
389
16.1
Betriebssystemhintergrund: Prozesse und Threads ...................................
16.1.1 Programme: Historie .........................................................................
16.1.2 Prozesse und Threads ........................................................................
16.1.3 Parallelität durch den Einsatz von Threads .....................................
389
389
391
392
16.2
Threads in C# ....................................................................................................
16.2.1 Thread-Erzeugung .............................................................................
16.2.2 Auch Threads brauchen ihren Schlaf ...............................................
16.2.3 Suspendieren von außen ..................................................................
16.2.4 Abbruch eines Threads .....................................................................
16.2.5 Warten auf das Ende eines Threads ................................................
16.2.6 Aktueller Thread-Zustand .................................................................
16.2.7 Thread-Prioritäten .............................................................................
16.2.8 Name eines Threads ..........................................................................
16.2.9 Zusammenfassung der wichtigsten Methoden und
Properties der Klasse Thread ............................................................
16.2.10 Übergabe und Rückgabe von Daten ...............................................
392
392
396
400
402
404
404
405
407
16.3
Synchronisierung ..............................................................................................
16.3.1 Die Gefahr von nicht synchronisierten Threads ............................
16.3.2 Die Klasse Monitor ............................................................................
16.3.3 Ein Monitor in C# ..............................................................................
408
408
410
412
16.4
Asynchrone Methodenaufrufe .......................................................................
16.4.1 BeginInvoke() und EndInvoke() .......................................................
16.4.2 Methodenaufruf ohne Parameter und Rückgabewert ..................
16.4.3 Methodenaufruf mit Parametern und Rückgabewert ...................
414
414
415
417
16.5
Zusammenfassung ............................................................................................ 420
16.6
Übungen ............................................................................................................ 421
407
408
Teil III Windows Forms
423
17
Einführung
425
17.1
Die Definition und Funktionsweise eines Fensters ................................... 425
17.2
Die Windows Forms-Bibliothek ....................................................................
17.2.1 Der Namensraum ..............................................................................
17.2.2 Fenster vs. Formulare .......................................................................
17.2.3 Grundgerüst für Windows Forms-Programme ..............................
427
427
427
428
17.3
Die Klasse Form im Detail ..............................................................................
17.3.1 Hinweise zur Online-Hilfe ................................................................
17.3.2 Wichtige Eigenschaften der Klasse Form .......................................
17.3.3 Wichtige Methoden der Klasse Form .............................................
17.3.4 Wichtige Ereignisse der Klasse Form ..............................................
430
430
430
437
441
Inhalt
13
17.4
17.5
14
Einfügen von Elementen in ein Fenster ........................................................
17.4.1 Einfügen einer Schaltfläche in ein Fenster ......................................
17.4.2 Das Koordinatensystem von Windows Forms ...............................
17.4.3 Die Positionierung von Elementen in einem Fenster mit
Hilfe der Dock- und Anchor-Eigenschaft ........................................
17.4.4 Das Baukastensystem von Windows Forms ...................................
Dialoge
17.5.1
17.5.2
17.5.3
447
448
450
451
455
............................................................................................................... 456
Dialoge mit ShowDialog() anzeigen ................................................ 456
Vorgefertigte Dialoge ........................................................................ 458
Die Klasse MessageBox ..................................................................... 458
460
460
462
465
17.6
Unterstützung durch die Entwicklungsumgebung .....................................
17.6.1 Ein neues Projekt anlegen ................................................................
17.6.2 Hinzufügen und Parametrieren eines Steuerelements ..................
17.6.3 Automatisch generierter Code .........................................................
17.7
Zusammenfassung ............................................................................................ 468
17.8
Übungen ............................................................................................................ 468
18
Steuerelemente
18.1
Die Basisklasse Control ...................................................................................
18.1.1 Eigenschaften .....................................................................................
18.1.2 Methoden ...........................................................................................
18.1.3 Ereignisse ............................................................................................
471
471
475
477
18.2
Containersteuerelemente ................................................................................
18.2.1 Formulare – Fenster ..........................................................................
18.2.2 Panels – Platten ..................................................................................
18.2.3 FlowLayoutPanel und TableLayoutPanel ........................................
18.2.4 SplitContainer ....................................................................................
18.2.5 GroupBox ............................................................................................
18.2.6 TabControl ..........................................................................................
18.2.7 Anmerkungen zum Umgang mit Containersteuerelementen ......
478
479
479
480
482
484
484
484
18.3
Schaltflächen, Checkboxen und Radiobuttons ............................................
18.3.1 Schaltflächen – Buttons .....................................................................
18.3.2 Optionsfelder Teil 1: Checkboxen ...................................................
18.3.3 Optionsfelder Teil 2: Radiobuttons .................................................
485
485
488
489
18.4
Textfelder ...........................................................................................................
18.4.1 Einfache Textein-/ausgaben: TextBox .............................................
18.4.2 Formatierte Eingaben: MaskedTextBox ..........................................
18.4.3 Dokumente mit Formatierungen: RichTextBox .............................
490
490
490
491
18.5
Beschriftungen .................................................................................................. 492
18.6
Bilder .................................................................................................................. 494
18.7
Listen und Tabellen ..........................................................................................
18.7.1 Einfache Listen: ListBox und CheckedListBox ................................
18.7.2 Aufklappbare Listen: ComboBox .....................................................
18.7.3 Listen und Tabellen: ListView ..........................................................
18.7.4 Bäume: TreeView ...............................................................................
Inhalt
471
494
495
495
496
497
18.8
Menüs, Symbolleisten und Kontextmenüs ..................................................
18.8.1 Menüs .................................................................................................
18.8.2 Symbolleisten .....................................................................................
18.8.3 Kontextmenüs ....................................................................................
497
497
499
500
18.9
Sonstige Steuerelemente ................................................................................
18.9.1 Darstellung von Objekteigenschaften: PropertyGrid ....................
18.9.2 Zeitlich wiederkehrende Aufgaben auslösen .................................
18.9.3 Fortschrittsanzeige und Schiebebalken: ProgressBar
und TrackBar ......................................................................................
500
500
501
502
18.10 Zusammenfassung ............................................................................................ 503
18.11 Übungen ............................................................................................................ 504
19
Grafik und Drucken in Windows FormsAnwendungen
505
19.1
Grafik – GDI+ ....................................................................................................
19.1.1 Einfache, grafische Ausgaben: Das Graphics-Objekt ....................
19.1.2 Der Garbage Collector und das Graphics-Objekt ..........................
19.1.3 Farben .................................................................................................
19.1.4 Stifte und Pinsel .................................................................................
19.1.5 Koordinaten und Punkte ..................................................................
19.1.6 Rechtecke ...........................................................................................
19.1.7 Größe des Zeichenbereichs ermitteln .............................................
19.1.8 Methoden zum Zeichnen .................................................................
19.1.9 Methoden zum Füllen von Flächen ................................................
19.1.10 Fehler in der grafischen Ausgabe ....................................................
19.1.11 Ausgabe einzelner Bildpunkte .........................................................
19.1.12 Grafische Pfade ..................................................................................
19.1.13 Regionen .............................................................................................
19.1.14 Erzeugen von Graphics-Objekten ...................................................
505
505
506
507
510
515
515
516
516
531
534
534
535
537
537
19.2
Icons und Bilder ............................................................................................... 537
19.2.1 Icons .................................................................................................... 538
19.2.2 Bilder ................................................................................................... 539
19.3
Drucken ..............................................................................................................
19.3.1 Ereignisse der Klasse PrintDocument .............................................
19.3.2 Eigenschaften der Klasse PrintDialog ..............................................
19.3.3 Erstellen einer Druckvorschau .........................................................
19.4
Unterstützung durch die Entwicklungsumgebung ..................................... 552
542
545
546
548
19.5
Zusammenfassung ............................................................................................ 552
19.6
Übungen ............................................................................................................ 553
20
Bibliotheken und CodeDOM
20.1
Bibliotheken ...................................................................................................... 555
20.1.1 Statische und dynamische Bibliotheken ......................................... 555
555
Inhalt
15
20.1.2
20.1.3
20.1.4
Unterschied zwischen einem Programm und einer Bibliothek .... 556
Ein einfaches Beispiel ........................................................................ 556
Projekte mit mehreren Code-Dateien ............................................ 559
CodeDOM .........................................................................................................
20.2.1 Ein Simulator für ein Makro .............................................................
20.2.2 Die Oberfläche der Anwendung ......................................................
20.2.3 Code zur Laufzeit erzeugen ..............................................................
20.2.4 Vorbemerkungen ...............................................................................
20.2.5 Die Methode OnClickedStart() ........................................................
20.3
Zusammenfassung ............................................................................................ 567
20.4
Übungen ............................................................................................................ 568
A
Fehlersuche in Programmen
A.1
Trace-Ausgaben ................................................................................................ 569
A.2
Der Debugger von Visual C# 2005 Express .................................................
A.2.1
Programme im Debugger starten ....................................................
A.2.2
Variablenwerte anzeigen ...................................................................
A.2.3
Weitere Debug-Fenster ....................................................................
B
Hilfequellen
B.1
Online-Hilfe ....................................................................................................... 579
B.2
Quickstart Tutorials ......................................................................................... 580
569
571
571
574
576
579
B.3
Webseiten .......................................................................................................... 581
B.4
Bücher ................................................................................................................ 582
Index
16
560
561
562
562
562
563
20.2
Inhalt
583
1
2
2
Aufbau von C#-Programmen
3
In diesem Kapitel lernen Sie den grundlegenden Aufbau von C#-Programmen kennen. Des Weiteren werde ich Sie mit Begriffen wie »Klasse«,
»Objekt«, »namespace« und »Assembly« sowie Syntax und Semantik
einer Programmiersprache vertraut machen.
4
5
6
Bevor wir uns in eine Unmenge von neuen Begriffen stürzen, möchte ich Ihnen gerne
ein erstes, kleines Programm – in C# geschrieben – vorstellen. Es trägt den Namen
»Hello-World«, benannt nach der Ausgabe, die es am Bildschirm erzeugt.
7
8
Dieses Programm besitzt einen großen Bekanntheitsgrad in der Entwicklergemeinde:
Fast jeder Programmierer hat es mindestens einmal geschrieben. Es veranschaulicht
auf einfache Art und Weise, aus welchen Sprachelementen ein minimales Programm
besteht. Seit seiner Erfindung vor vielen Jahren hat es sich hartnäckig in der einschlägigen Literatur gehalten.
10
2.1
11
9
Hello, World!
Da ich mit dieser »Tradition« nicht brechen möchte, finden Sie im nachfolgenden Listing 2.1 die C#-Version1 des »Hello-World« Programms.
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
12
/*
HelloWorld.cs
Das Programm gibt "Hello, World!" am Bildschirm aus
und beendet sich danach
*/
13
class HelloWorld
{
public static void Main()
{
System.Console.WriteLine("Hello, World!");
}
}
16
14
15
17
18
19
Listing 2.1 Das erste C#-Programm (HelloWorld).
20
Es gilt nun zunächst, dieses Programm zum Laufen zu bringen. Starten Sie hierfür die
Entwicklungsumgebung Visual C# 2005 Express, indem Sie den Eintrag Visual C#
2005 Express Edition im Startmenü Ihres Windows-Systems anklicken. Danach
erscheint nach kurzer Wartezeit die Entwicklungsumgebung auf Ihrem Bildschirm
(Abbildung 2.1).
A
B
1 Im Buch »C#« von Eric Gunnerson (ebenfalls bei Galileo Computing erschienen), heißt es
auch »Hello, Universe!« – wiederum frei nach dem ausgegebenen Text.
Aufbau von C#-Programmen
29
Abbildung 2.1 Die Entwicklungsumgebung, wie sie sich nach dem Start präsentiert.
Wenn Sie die Entwicklungsumgebung gestartet haben, sehen Sie zunächst die Startseite: Auf ihr finden Sie Informationen über Visual C# 2005 Express Edition (in der
Mitte), die zuletzt bearbeiteten Projekte und kleine Anleitungen, genannt Erste
Schritte. Möchte man ein Programm erstellen, muss dazu zunächst ein Projekt erzeugt
werden: Projekte erfüllen Verwaltungsaufgaben; so enthalten sie Informationen darüber, welche Art von Programm2 erstellt und aus welchen Dateien der C#-Code für
die Anwendung entnommen werden soll.
Sie müssen also zunächst ein neues Projekt erstellen. Klicken Sie hierzu in dem
Bereich Zuletzt geöffnete Projekte hinter dem Eintrag Erstellen den Schriftzug Projekt
mit der linken Maustaste einmal an (Abbildung 2.2).
Wählen Sie in dem darauf folgenden Dialog den Eintrag Konsolenanwendung aus
(Abbildung 2.3); Sie können zudem im Feld Name einen anderen als den vorgeschlagenen Namen für das Projekt eingeben. Für alle Programme, die im Rahmen dieses
Buches im weiteren Verlauf angeführt werden, können Sie Projekte dieses Anwendungstyps erstellen; Ausnahmen werde ich als solche kennzeichnen. Wenn Sie diesen
Dialog durch einen Klick auf die Schaltfläche OK schließen, wird ein neues Projekt
angelegt und geöffnet.
2 Konsolen-, Windows-Anwendungen und Bibliotheken sind die Arten, die am häufigsten benötigt werden.
30
Aufbau von C#-Programmen
1
2
3
4
5
6
Abbildung 2.2 Sie können ein neues Projekt über die Startseite erstellen,
indem Sie auf den Eintrag Projekt hinter Erstellen klicken.
7
8
9
10
11
12
13
14
Abbildung 2.3 Erstellen Sie zunächst Konsolenanwendungen.
Der Arbeitsbereich von Visual C# 2005 Express ist üblicherweise in drei Teile geteilt:
In der Mitte sehen Sie einen Texteditor, am rechten Rand im oberen Teil den Projektmappen-Explorer und darunter das Eigenschaftsfenster. Am unteren Rand sehen Sie
eine – hoffentlich leere – Liste mit aufgetretenen Fehlern (Abbildung 2.4).
15
Falls Sie nicht das gleiche Fenster wie in Abbildung 2.4 sehen, kann dies daran liegen,
dass noch nicht alle Ansichten ausgeklappt sind. Fahren Sie in diesem Fall mit der
Maus auf die sich an den Rändern befindlichen Schaltflächen; wenn Sie mit dem
Mauszeiger kurz über diesen verweilen oder auf sie klicken, fährt das zugehörige
Fenster heraus. Sie können dies dann durch einen Klick auf das Pinnwand-NadelSymbol des jeweiligen Fensters verankern. Falls Ihnen die Gestaltung des Arbeitsbereichs nicht zusagt, können Sie die Fenster auch an andere Ränder verschieben: Ziehen Sie diese hierzu einfach mit der Maus an den entsprechenden Fensterrand.
Haben Sie ein Fenster aus Versehen geschlossen, können Sie dieses über das Menü
Ansicht wiederherstellen.
17
16
18
19
20
A
B
Hello, World!
31
Abbildung 2.4 Der Arbeitsbereich von Visual C# 2005 Express
2.1.1
Der Projektmappen-Explorer
Der Projektmappen-Explorer verwaltet die gerade geöffneten Projekte in Visual C#
2005 Express. Eine Projektmappe besitzt mindestens ein Projekt. Ein Projekt wiederum besteht aus Eigenschaften3, Verweisen und einzelnen Dateien mit C#-Code.
Die Eigenschaften eines Projekts werden in Form einer Datei, meist AssemblyInfo.cs genannt, angegeben. Diese enthält C#-Code, so genannte Attribute4. Man
kann hier die aktuelle Versionsnummer, den Autor usw. einstellen. Der Ordner Verweise enthält zusätzliche Abhängigkeiten, die die Anwendung benötigt, um später
ausgeführt werden zu können. Darunter finden Sie die einzelnen Dateien, aus denen
das spätere Programm zusammengebaut wird.
Abbildung 2.5 Der Projektmappen-Explorer zeigt Projekte in einer Ordnerstruktur an.
3 engl. Properties
4 Attribute werden im Kapitel 14 ausführlich erläutert.
32
Aufbau von C#-Programmen
1
2
2.1.2
Das Eigenschaftsfenster
3
Wenn Sie ein Element im Projektmappen-Explorer ausgewählt haben, werden in diesem Fensterchen die dem Element zugeordneten Eigenschaften angezeigt. Bitte
beachten Sie, dass Sie nicht alle Eigenschaften ändern können, da einige nur lesbar
sind. Diese werden dann in grauer Farbe dargestellt.
2.1.3
4
5
Die Fehlerliste
6
Die Fehlerliste wird erst ein wenig später benötigt; sie enthält eine Auflistung aller
Fehlermeldungen und Warnungen, die vom C#-Compiler während des Übersetzungsvorgangs erzeugt wurden. Lässt sich Ihr Programm nicht übersetzen, finden Sie meist
den Grund dafür in diesem Fenster. Ein Doppelklick auf einen Eintrag führt Sie dann
zu der entsprechenden Zeile in Ihrem Quellcode, an der der Fehler oder die Warnung
aufgetreten ist: Ein Programm muss fehlerfrei sein, sonst lässt es sich nicht ausführen.
Warnungen geben Hinweise an den Programmierer, dass er oder sie sich um eine
bestimmte Stelle im Code nochmals Gedanken machen sollte – diese können und
sollten beachtet werden, aber das ist kein Zwang.
10
2.1.4
11
7
8
9
Der Texteditor
Das Herzstück der Entwicklungsumgebung bildet der Texteditor in der Mitte des
Visual C# 2005 Express Fensters: Hier geben Sie Ihre Programme ein. Löschen Sie den
Text, der automatisch für Sie generiert wurde, und tippen Sie dafür den in Listing 2.1
gezeigten Code ein (Abbildung 2.6). Speichern Sie nach der Eingabe die Datei über
das entsprechende Symbol in der Symbolleiste oder über das Menü Datei.
12
13
14
Auch wenn das Kopieren der hier vorgestellten Programme sehr einfach geht,
schreiben Sie sie ab! Viele Dinge lernt man besser, wenn man sie praktisch übt.
Dazu gehören auch simpel aussehende Programme.
15
16
Wenn Sie alles richtig abgetippt haben, können Sie versuchen, das Programm mit
dem Compiler übersetzen: Wählen Sie hierfür den Eintrag Projektmappe erstellen aus
dem Menü Erstellen oder drücken Sie die Taste (F6).
17
18
Sollten im Programm Fehler vorhanden sein, bekommen Sie diese mit einer (mehr
oder weniger genauen) Fehlermeldung sowie der betreffenden Zeilennummer vom
Übersetzer gemeldet. Diese Fehlermeldungen werden in der Fehlerliste eingetragen.
19
20
C#-Programme sind casesensitive, d.h. es wird zwischen Groß- und Kleinschreibung unterschieden! Wenn Fehler auftreten, vergewissern Sie sich zunächst, dass
nicht nur das entsprechende Wort korrekt geschrieben wurde, sondern auch die
Schreibweise zu 100 % übereinstimmt!
Hello, World!
A
B
33
Index
-- (Post-Dekrement) 108
-- (Pre-Dekrement) 117
- (Subtraktion) 103, 285
- (Vorzeichen) 116, 283
! 116, 283
-- 283
!= 120, 287
#define 382
#elif 382
#else 382
#endif 382
#endregion 385
#error 385
#if 382
! 384
!= 384
&& 384
== 384
|| 384
#line 385
#region 385
#undef 382
#warning 385
% 104, 285
%= 105
& 122, 285
&& 123, 289
&= 123
() (Methodenaufruf) 107, 165
() (runde Klammern) 106
() (Typumwandlung) 118
* 103, 285
*= 105
+ 103, 285
+ (Vorzeichen) 283
+ (Zeichenketten) 104
++ 283
++ (Post-Inkrement) 108
++ (Pre-Inkrement) 117
+= 105, 298, 300
, 132
. (Memberzugriff) 107, 161, 289
.NET
.NET Framework 19
Assembly 42
C# 22
COM Interop 20
Common Language Runtime (CLR) 43
Compact Framework 20
Exceptions 18
Garbage Collection 17
IL Disassembler 43
Intermediate Language 20
Just-In-Time Compiler 20
Linux 20
Memory Leaks 21
Mono 20
Polymorphie 18
Übersicht 17
Webservices 18
/ 103, 285
/* */ 371
// 371
/// 371
/= 105
/unsafe 112
< 120, 287
<< 119, 285
<<= 119–120
<= 287
<list>
bullet 380
number 380
table 380
-= 105, 298, 300, 304
= 105, 289
== 120, 249, 287
> 120, 287
>= 120, 287
>> 119, 285
>>= 119
?: 124, 289
[] 108, 319
^ 122–123, 285
^= 123
| 122, 285
|= 123
|| 123, 289
~ 117, 283
~ (Destruktor) 206
A
Ableitungshierarchie 218
abstract 194–195
Alignment 113
AnchorStyles 453
anonyme Methoden 309
AppDomain 76
Index
583
Application 468
ArgumentNullException 275
Array 68
Deklaration 69
foreach 70, 138
Initialisierung 69
mehrdimensionale Arrays 72
unregelmäßige Arrays 73
Zugriff 70, 108
ArrayList 331
Member 331
as 121, 180
Assembly 355, 486
GetExecutingAssembly() 355
GetModules() 357
GetName() 357
AssemblyCompany 364
AssemblyCopyright 364
AssemblyDescription 364
AssemblyInfo.cs 349
AssemblyName 357
CodeBase 357
Name 357
Version 357
AssemblyProduct 364
AssemblyTitle 364
AssemblyTrademark 364
AssemblyVersion 364
AsyncCallback 418
asynchrone Methodenaufrufe 414
BeginInvoke() 414
Callbacks und Zustandsobjekt 418
EndInvoke() 414
Methodenaufruf mit Parametern
und Rückgabewert 417
Methodenaufruf ohne Parameter
und Rückgabewert 415
AsyncResult 419
AsyncDelegate 419
AsyncWaitHandle 417
Attribute 341, 350
AssemblyInfo.cs 349
aus Metadaten auslesen 362
durch C# reservierte 342
eigene erstellen 349
erweiterte Syntax 348
globale 349
im Code platzieren 342
Syntax 342
Ziele 352
AttributeTargets 347
Werte 347
584
Index
AttributeUsage 342, 347
Properties 348
Aufzählung 89
Ausgabe 62
formatiert 63
Variablen 62
Währung 64
Ausnahme 167
B
base 184, 233
Bedingungen 139
if 139
switch-case 144
Benutzeroberfläche 425
Beschriftungen
Label 492
LinkLabel 492
Bezeichner 53
Bézier-Kurve 519
Bibliotheken 555
dynamische 555
Main() 556
statische 555
Bilder 539
Formate 539
Bildlisten 542
Bildschirmausgaben 41
binäre Periodizität 51
BindingFlags 359
Bitmap 539
GetPixel() 541
SetPixel() 541
Bitmaske 122
bool 52, 364
BorderStyle 479
Bottom-Up 362
Boxing 85, 89, 119, 213, 288
break 138, 144
Brush 506, 512
Brushes 515
Button 485, 561
Click 485, 567
ImageAlign 487
TextAlign 487
Buttons 485
byte 50, 364
C
CancelEventArgs 442–443
Cancel 442–443
CancelEventHandler 442
Cardinal-Spline-Kurve 521
case 144
Cast 118, 300
catch 272
Category 501
char 50, 247, 364
CheckBox 488
Checked 488
CheckedChanged 488
CheckState 488
CheckStateChanged 488
ThreeState 488
checked 113
CheckedListBox 495
CheckState 488
class 157
CloseReason 442
CodeDOM 560, 562
Collection 250
Collections 330
ArrayList 331
Hashtable 337
Queue 333
Stack 335
Color 507–508
FromArgb() 508
GetBrightness() 509
GetHue() 509
GetSaturation() 509
COM 222, 341
ComboBox 495
CompilerParameters 563
CompilerOptions 564
ReferencedAssemblies 564
ReferencedAssemblies.Add() 564
CompilerResult
Errors 565
CompilerResults 564
Component Object Model 222, 341
Conditional 342, 344
Console 42, 76, 569
const 76
Constraints 223
Container 238
Anmerkungen 484
Dock & Anchor 484
Fenster, Formulare 479
FlowLayoutPanel 480
GroupBox 484
Panels 479
SplitContainer 482
TabControl 484
TableLayoutPanel 480
Container-Controls 456
ContextMenuStrip 500
continue 138
Control 456, 471, 506
Anchor 473
BackColor 472
BackgroundImage 472, 494
BackgroundImageLayout 472
BeginInvoke() 474–475
Click 456, 477
ClientSize 516
Contains() 475
CreateGraphics() 475, 537
Cursor 472–473
Dispose() 475
Dock 473
DoubleBuffered 438
DoubleClick 477
Eigenschaften 471
Enabled 474–475
EndInvoke() 474–475
Ereignisse 477
FindForm() 475
Focus() 475
Font 472
ForeColor 473
GetChildAtPoint() 476
GetContainerControl() 476
GetNextControl() 476
GetStyle() 438, 476
Hide() 476
Invalidate() 476
Invoke 474
Invoke() 475, 501
InvokeRequired 474–475
KeyDown 477
KeyPress 477
KeyUp 477
Location 473
Margin 473
MaximumSize 473
Methoden 475
MinimumSize 473
MouseClick 477
MouseDoubleClick 477
MouseDown 477
MouseEnter 478
MouseHover 478
MouseLeave 478
Index
585
MouseMove 478
MouseUp 477
MouseWheel 478
Move 478
OnPaint() 541–542
Padding 473
Paint 478, 541
Parent 474
Refresh() 476
Resize 478
RightToLeft 473
SetStyle() 438, 476
Show() 476
Size 473
TabIndex 474, 476
TabStop 474, 476
Tag 473
Text 473
Update() 476
UseWaitCursor 473
Visible 474–475
ControlStyles 438
AllPaintingInWmPaint 438
OptimizedDoubleBuffer 438
CSharpCodeProvider 563
CYMK-Farbmodell 509
D
DashStyle
Enumerationsmember 510
DateTime 491
Debug 569
WriteLine() 569
Debuggen 124
Debugger 571
Haltepunkt 571
Tastenkombinationen 571
Variablenwerte anzeigen 574
decimal 52
default 144
Deklaration
Inline 309
Delegate
BeginInvoke() 416
EndInvoke() 416
delegate 292
Delegates 291
Aufruf 294
Combine() 298
Deklaration 292
Erzeugung 295
Exceptions im Callback 301
586
Index
Generische 309
GetInvocationList() 301
Multicast-Delegates 297
Remove() 298
Rückgabewerte 301
Schreibweise in C# 2.0 310
Typparameter 309
Verwendung 293
Description 501
Destruktor 206, 237
Deklaration 206
Dialoge
vorgefertigte 458
DialogResult 456
Dispose() 236
DivideByZeroException 275
DLL 555, 557
do 136
DockStyle 452
Dokumentations-Tags
371, 373–374, 376–380
Übersicht 372
double 52, 364
Double Buffering 438
do-while 136
Drucken 542
Druckvorschau 548
Seitenvorschau 551
E
Effizienz 216
Eigenschaftsfenster 33
Einschränkungen 223
Einsprungspunkt 38, 40
elementare Datentypen 49
else 139
enum 91
Enumeration 89
Basistyp 93
Deklaration 91
Zuweisung von Werten 91
Enumeratoren 321
Definition 321
typsicher 328
Verwendung 327
Ereignisse 302
Deklaration 305
Hintergrund 305
Rückgabewerte 309
Vergleich mit Delegate 302
Escape-Sequenzen 59–60, 261
Übersicht 59
EVA-Prinzip 47
event 305
EventArgs 307, 441
EventHandler 441–442, 447, 477–478
Events 304
Source und Sink 307
Exception 167, 200, 237
Exceptions 269
.NET 271
caller beware 281
caller confuse 281
caller inform 281
eigene Exception-Klassen 277
Exception-Klassen 274
fangen 269, 272
finally 278
Funktionsweise 269
in C# 271
in Delegates 301
Klasse 271
Member 273
Nachteile 270
Nachteile, Codierungsaufwand 270
Nachteile, Performance 270
Verhaltensweisen 279
Werfen 269, 271
F
false 52, 283
Farben 507
Fehlerliste 33
Feld 68
Fenster 425, 427
Definition und Funktionsweise 425
Einfügen von Elementen 447
Nachrichten 426
Titel 473
transparent 434
FIFO 333
FileNotFoundException 540
FillMode 532, 535
Finalize() 236
Finalizer 237
finally 278
Flag 148
float 52, 364
FlowLayoutPanel 480
for 129, 247, 321
foreach 70, 138, 247, 321, 327, 330
Form 427, 473, 479
Activate() 437
Anchor 451, 453
BackColor 431
BackColorChanged 441
BackgroundImage 431
BackgroundImageChanged 441
ClientSize 431, 436, 450, 516
Close() 429, 437, 456
Closed 442
Closing 440, 442
ContextMenu 431
ControlBox 431
Controls 431
DefaultSize 436
DesktopBounds 432
DesktopLocation 432
Details 430
Dock 451–452
DoubleBuffered 438
Einfügen von Elementen 447
EventHandler 446
Fenstertitel 473
FormBorderStyle 432
FormClosed 442
FormClosing 442
GetChildAtPoint() 446
GetStyle() 438
HelpButton 433
HelpButtonClicked 433, 443
HelpRequested 433, 443
Hide() 438
Icon 434
InitializeComponent() 450
Koordinatensystem 450
Load 446
Location 452
MaximizeBox 431, 433–434
MaximumSize 434
MinimizeBox 431, 433–434
MinimumSize 434
Name 434
OnClosing() 440
OnHelpButtonClicked() 443
OnHelpRequested() 445
OnPaint() 441, 506
Opacity 434
Paint 441, 446, 506
PointToClient() 445
Refresh() 440
Resize 446
ResizeBegin 446
ResizeEnd 446
ResizeRedraw 435
ResumeLayout() 467
Index
587
SetStyle() 438
Show() 438, 440, 456
ShowDialog() 440, 456, 550
ShowIcon 431, 435
ShowInTaskbar 435
Shown 447
Size 436
SizeChanged 446
SizeGripStyle 436
SuspendLayout() 467
Text 436
Visible 437–438, 447
VisibleChanged 447
wichtige Eigenschaften 430
wichtige Ereignisse 441
wichtige Methoden 437
WindowState 437
formatierte Ausgabe 63
Formatierungszeichen 65
FormBorderStyle 432
Aufzählungsmember 432
FixedDialog 456
FormClosedEventArgs
CloseReason 442
FormClosedEventHandler 442
FormClosingEventArgs 443
CloseReason 442
FormClosingEventHandler 442
Formulare 427
FormWindowState 437
G
ganzzahlige Werte 50
Garbage Collection 21, 73
Garbage Collector 74, 88, 163, 205, 236
GDI+ 427, 505
Bildlisten 542
Fehler in der Ausgabe 534
Füllen von Flächen 531
Grafische Pfade 535
Icons und Bilder 537
Koordinaten & Punkte 515
Methoden zum Zeichnen 516
Punkte ausgeben 534
Rechtecke 515
Regionen 537
Stifte & Pinsel 510
gebrochene Werte 51
GenerateMember 463
Generics 213
Collections in .NET ab v2.0 331
588
Index
generische Klassen
Vererbung 216
generische Methoden 217
get 198
Gleitkommadatentypen 52
Globale Attribute 349
goto 148
Sprungmarken 148
grafische Benutzeroberfläche 425
Graphics 505
DrawArc() 518, 528
DrawBezier() 519
DrawBeziers() 519
DrawClosedCurve() 521
DrawCurve() 521
DrawEllipse() 523
DrawIcon() 524
DrawIconUnstretched() 524
DrawImage() 525
DrawImageUnscaled() 525
DrawImageUnscaledAndClipped()
525
DrawLine() 526
DrawLines() 526
DrawPath() 527, 536
DrawPie() 528
DrawPolygon() 529
DrawRectangle() 530
DrawRectangles() 530
DrawString() 530
Erzeugen 537
FillClosedCurve() 532
FillPath() 532, 536
FillPolygon() 532
FillRegion() 534
Garbage Collection 506
GraphicsPath 514, 527, 535
CloseFigure() 536
Hinzufügen geometrischer Formen
535
GroupBox 484, 489
Gültigkeitsbereich 67
H
Haltepunkt 571
Handler 301
Hashtable 288, 337
Hashwert 288
Schlüssel 337
Hashwert 288
HatchBrush 511–512
HatchStyle 513
Hello, World! 29
HelpEventArgs 444
HelpEventHandler 444
HSB-Farbmodell 509
I
IAsyncResult 415, 418
AsyncState 420
ICodeCompiler 563
Icon 538
ExtractAssociatedIcon() 539
Icons 538
IDisposable 236
Dispose() 236
IEnumerable 321
Member 322
IEnumerator 321
Current 322
Member 322
MoveNext() 322
Reset() 322
if 139
Hintereinanderschaltung 142
Schachtelung (Kaskadierung) 141
Image 539
FromFile() 540
Save() 542
ImageList 542
Indexer 247, 315
Indizierer 315, 319
Deklaration 315
mit mehreren Parametern 320
this 319
Verwendung 318
Inline-Deklaration 309
Instanzdaten 159
int 50, 364
interface 218
Intermediate Language 20, 50
internal 157, 182–183
internal protected 182, 184
InvalidOperationException 323
is 121, 180
J
Java
Java 21
Java Byte-Code 21
Java-Applet 21
K
KeyEventHandler 477
KeyPressedEventHandler 477
Klassen 155–156
abstrakte Klassen 194
Aufruf des Basisklassenkonstruktors 184
Begriffsdefinition 156
Deklaration 39, 157
Finalize() und Destruktoren 206
generisch 213
Implementierung einer
Schnittstelle 220
Instantiierung 158
Instanz 158
Instanzdaten 159
Klassenmember 224
konkrete 216
Konstruktor 172
kurze Einführung 38
mehrere Konstruktoren 175
Memberdaten 159
partial 202
private Konstruktoren 227
Properties 196
Referenzen auf Basisklassen 180
Schnittstelle 218
sealed 187
Sichtbarkeitsspezifizierer 157, 182
Standardkonstruktor 173
statische 226
statische Konstruktoren 176
Überladen von Methoden 188
Überschreiben von Methoden 191
Umbenennung 96
Vererbung 177
virtuelle Methoden 191
Klassenbibliothek 556
Klassendiagramm 157
Klassenfabrik 184
Klassenmember 224
Daten 225
Eigenschaften 226
Methoden 225
Kommentare 35
Blockkommentar 36
Dokumentationskommentar 371
Zeilenkommentar 37, 371
Konkatenation 104
Konstante 41, 57
Konstruktor
private 184
Index
589
Konvertierungshierarchien 119
kritischer Fehler 267
L
Label 492
AutoEllipsis 493
AutoSize 493
Ländereinstellungen 64
LIFO 335
LinearGradientBrush 512
LinkLabel 492
LinkArea 493
LinkBehavior 493
LinkClicked 494
LinkColor 493
LinkVisited 493
ListBox 495
Items 495
MultiColumn 495
SelectedIndex 495
SelectedIndices 495
SelectedItem 495
SelectedItems 495
SelectionMode 495
Sorted 495
ListView 496, 542
Columns 496
Groups 496
Items 496
View 496
Literal 41, 57
boolesches 59
ganzzahlig 57
Qualifizierer 58
reales (Gleitkomma) 58
Stringliteral 60
Zeichenliteral 59
lock 402, 412
long 50, 364
M
Main() 40, 166, 225, 556
Parameter 74
Makros 560
Manifest 43
MaskedTextBox 490
Mask 491
Validate() 491
Masken 122
Match 263
Member 263
Mehrfachvererbung 218
590
Index
Member
öffentlich 183
Memberdaten 159
Initialisierungsreihenfolge 174
MemberInfo 359
MemberTypes
Werte 359
Memberzugriffsoperator 107
Menüs 497
Kontextmenüs 500
MenuStrip 498
GripStyle 498
MessageBox 446, 458, 485, 561, 565
Icon 459
MessageBoxIcon 459
Metadaten 353
Metafile 539
Metazeichen 260
Quantifizierer 260
Methode 40, 182
abstrakte 195
anonyme 309
Argumente 166
Aufruf 165
Aufruf (Operator) 107
Dispatching, virtuell 209, 232–233
generische 217
mit Parameter 166
mit Rückgabewert 170
Name 164
Neuimplementierung 228, 230
Out-Parameter 204
Parameterliste 164–165
Polymorphie 192
Ref-Parameter 203
Rückgabetyp 163
sealed vor virtuelle Methoden 233
statische 225
Überladen 188
Überladung 189
Verweis auf eine Methode 295
virtuelle 191–192
Zugriff auf statische Member 226
Methodenrumpf 40
MethodInfo 361, 566
GetCustomAttributes() 363
GetParameters() 361
Invoke() 566
Name 361
ReturnType 361
Microsoft.CSharp 563
Module 356
GetTypes() 358
Monitor 410
Enter() 410
Exit() 410
Hinweise zur Verwendung 412
in C#
lock 412
MouseEventArgs 477
MouseEventHandler 477–478
mscorlib 43
Multicast-Delegates 297
Multitasking 391
Multithreading 392
N
Nachrichten 426, 429
Nachrichtenschleife 429
Namenskonventionen für Variablen 53
Namensraum 41, 94
Definition 94
Schachtelung (Kaskadierung) 95
namespace 94
Nassi-Shneiderman 127
do-while 136
for 131
foreach 138
if 140
switch-case 146
while 134
NDoc 370
new 73, 88, 109, 158, 289, 295
new (Neuimplementierung von
Methoden) 230, 234
Notifizierung 292
null 180
O
Object 354, 359
Equals() 287
GetHashCode() 288
GetType() 354
Member 187
ToString() 257
object 89, 187, 354, 364
Objekte 155–156, 158
Erzeugung 158
Gleichheit 188
Konstruktor 172
Lebenszeit 161
mehrere Konstruktoren 175
Objektmethoden 163
Objektmethoden mit Parametern 166
Objektmethoden mit
Rückgabewert 170
Referenztypen 161
Selbstreferenz 169
Standardkonstruktor 173
statische Konstruktoren 176
Obsolete 342–343, 363
Parameter 343
Online-Hilfe 579
Operatoren 101
additive und multiplikative 103
arithmetische 103
bedingte 123
Bedingung 124
logische 122
primäre 106
relationale 120
Shift 119
unäre 116
Operatorüberladung
binäre Operatoren 285
Einschränkung 289
unäre Operatoren 283
Vergleichsoperatoren 287
zusammengesetzte Zuweisungsoperatoren 289
out 169
OutOfMemoryException 540
override 192, 196
P
PaintEventArgs 506
Eigenschaften 506
Panel 479
Parameterliste 164–165
Parameterübergabemechanismen 167
call-by-reference 169, 203
call-by-value 167
Parser 368
partial 202
PathGradientBrush 512
SurroundColors 515
Pen 506, 510
Brush 510
Color 510
DashStyle 510
Width 510
PictureBox 494
Image 494
SizeMode 494
PictureSizeMode 494
Index
591
Pinsel 512
Point 450, 515
Empty 451
PointF 515
Polymorphie 192
Präprozessor 367, 381, 570
Definieren von Symbolen 382
Präprozessordirektiven 367, 381
Ein- und Ausblenden von Code 381
Präprozessorsymbole 344
PreviewPageInfo 552
PreviewPrintController
GetPreviewPageInfo() 552
primitive Datentypen 49
PrintController 548
PrintControllerWithStatusDialog 548
PrintDialog 543
AllowCurrentPage 547
AllowPrintToFile 547
AllowSelection 547
AllowSomePages 547
Eigenschaften 546
PrintToFile 547
ShowHelp 547
ShowNetwork 547
PrintDocument 543
BeginPrint 546
EndPrint 546
Ereignisse 545
Print() 543
PrintPage 543, 545
QueryPageSettings 546
PrintEventArgs 546
PrintEventHandler 546
PrintPageEventArgs 544
PrintPreviewControl 550
Eigenschaften 550
PrintPreviewController 548
PrintPreviewDialog 548
ShowDialog() 550
private 82, 182–183
ProgressBar 502
Maximum 502
Minimum 502
Value 502
Projektmappe 32
Projektmappen-Explorer 32
Properties 196
Deklaration 197
Getter 198, 219
Nutzung 201
Setter 198, 219
592
Index
PropertyGrid 463, 500
SelectedObject 500
protected 182–183
Prozesse 389
Scheduling 390
public 82, 157, 182
Q
Qualifizierer 58
QueryPageSettingsEventArgs 546
QueryPageSettingsEventHandler 546
Queue 333
Member 334
Quickstart Tutorials 580
R
RadioButton 489
Checked 489
ReadLine() 76
Rectangle 432, 506, 515
Bottom 516
Contains() 516
Height 516
Inflate() 516
Intersect() 516
IntersectsWith() 516
Left 516
Location 516
Offset() 516
Right 516
Size 516
Top 516
Union() 516
Width 516
X 516
Y 516
RectangleF 516
ref 169
Reference 559
Referenzen 86
Reflection API 111, 341, 353, 562, 565
Regex 259
Match() 263
Optionen 262
RegexOption 262
Member 262
Region 534, 537
reguläre Ausdrücke 259
Assertionen 261
Aufbau 260
Metazeichen 260
Quantifizierer 260
Suchen und Ersetzen 263
Zeichenklassen 261
Ressourcen-Editor 487
return 171
RGB-Farbmodell 507
Alpha-Kanal 508
RichTextBox 491
Lines 491
LinkClicked 492
Select() 491
Selected 491
Text 491
Rückgabetyp 163
S
sbyte 50
Schaltfläche 448, 485
Schleifen 128
Abbruch 138
do-while 136
for 129
foreach 138
Fortsetzung mit nächstem
Durchlauf 138
while 133
Schlüsselwörter
Übersicht 53
Schnittstelle 218, 291
Deklaration 218
Properties 219
Typparameter 222
sealed 187, 233
Seiteneffekt 167
SelectionMode 495
Semantik 38
Serialisierung 341
set 198–199
short 50, 364
Sichtbarkeitsspezifizierer 157, 159–160,
163, 184
Size 431, 434, 436, 516
SizeGripStyle 436
sizeof 111
Smarttag 239
SolidBrush 512
Spaghetti-Code 148
Spezialisierung 179
SplitContainer 482
Sprungmarken 148
Stack 88, 335
Member 335
StandardPrintController 548
static 76, 224–225, 298
Steuerelemente
Bäume 497
Beschriftungen 492
Bilder 494
Checkboxen 485, 488
Container 478
Fortschrittsanzeige 502
Listen & Tabellen 494
Menüs, Symbolleisten & Kontextmenüs 497
PropertyGrid 500
Radiobuttons 485, 489
Schaltflächen 485
Schiebebalken 502
Textfelder 490
Zeitgeber 501
Stifte 510
string 53, 162, 245, 364, 490
CompareTo() 247, 289
EndsWith() 250
Format() 255
IndexOf() 251
Insert() 254
LastIndexOf() 251
Length 246
Remove() 253
Replace() 253
Split() 251
StartsWith() 250
Substring() 254
ToLower() 253
ToUpper() 253
Trim() 252
TrimEnd() 252
TrimStart() 252
weitere Methoden 255
StringBuilder 255
Konstruktoren 256
Properties und Methoden 256
Strings 41, 245
[] 246
Interning 249
Iteration über eine Zeichenkette 246
Konkatenation 104
Länge 246
Vergleich zweier Zeichenketten 247
struct 81
Struktur 81
Deklaration 81
Memberzugriff 83
Verschachtelung 84
Index
593
Strukturen
Konstruktor 172, 176
statische Konstruktoren 176
switch 142, 144
default-Alternative 144
mehrere Alternativen für einen Block
146
Synchronisation 408
Syntax 38
verwendete Schreibweise 38
System.CodeDom 563
System.CodeDom.Compiler 563
System.ComponentModel 442, 501
System.Console 45
System.Diagnostics 569
System.dll 564
System.Drawing 427, 450, 508, 512
System.Drawing.dll 564
System.Drawing.Drawing2D 510, 512,
532
System.Drawing.Printing 543
System.Object 187
System.Reflection 563
System.Reflection.Emit 568
System.Threading 393
System.Type 364
System.Windows.Forms 427, 471, 505
System.Windows.Forms.dll 564
SystemBrushes 515
SystemColors 509
SystemIcons 538
SystemPens 512
T
TabControl 484
TableLayoutPanel 480
Tags 369
Tastatureingaben 76
TextBox 490
Lines 490
Multiline 490
PasswordChar 490
Text 490
UseSystemPasswordChar 490
Textfelder
MaskedTextBox 490
RichTextBox 491
TextBox 490
TextureBrush 512
ToBitmap() 512
this 169, 226, 316, 319, 411
594
Index
Thread 389, 392
Abort() 403
aktueller 64
Beendigung von Threads 393
Erzeugung 392
Interrupt() 398
IsAlive 405
IsBackground 394
Join() 404
Ländereinstellung 64
Main-Thread 391
Member 407
Name 407
Priority 405
ResetAbort() 403
Resume() 400
Sleep() 396
Sleep(0) 398
Start() 393
Suspend() 400
suspendieren 400
Thread-Prozedur 392
Vorder- und HintergrundThreads 391, 394
Zustände 395
ThreadAbortException 403
Threading 389
ThreadInterruptedException 399
Thread-Pool 414
ThreadPriority 406
Thread-Prioritäten 406
ThreadStart 393
ThreadState 404
AbortRequested 403
Background 395
Running 393, 395
Stopped 395
Suspended 400
SuspendRequest 400
Unstarted 393, 395
WaitSleepJoin 396
ThreadStateException 393
throw 271
Timeout 398
Infinite 398
Timer 502
Enabled 502
Interval 502
Start() 502
Stop() 502
Tick 502
ToolBar 542
Toolbox 462, 483
ToolStrip 499
ToolStripContainer 497, 499
Top-Down 362
ToString() 257, 363
Trace-Ausgaben 569
Tracing-Tabellen 166
TrackBar 502
Maximum 502
Minimum 502
Scroll 503
Value 503
TreeView 497, 542
CheckBoxes 497
Nodes 497
SelectedNode 497
true 52, 283
Type 354, 357
BaseType 359
FullName 358
typeof 111
Typparameter 213, 222–223
Delegates 309
Einschränkungen 223
Vererbung 216
where 223
Typqualifizierer 59, 75
Typsicherheit 216
Typumwandlung 118, 180, 300
U
uint 50
ulong 50
UML 157
Assoziationen 238
Kardinalität 238
Klassendiagramm 178
Schnittstellen 237
Vererbung 177
Unboxing 85, 89, 119, 213, 288
unchecked 113
Unified Modelling Language 157
unsafe 111
ushort 50
using 46, 96, 342
using System.Runtime.Remoting.
Messaging 418
V
value 199
Variablen 48
Deklaration 55
Einlesen von der Tastatur 76
Initialisierung 56, 61
Wertzuweisung 56, 61
Variableninitialisierung 56, 61
Vererbung 177
Ableitungshierarchie 178
Basisklasse 178
Kind/Child 178
mehrfache 218
Referenzen auf Basisklassen 180
Syntax einer Ableitung 179
Typparameter 216
Vater/Parent 178
Zugriff auf Methoden der
Basisklasse 233
Verweis 559
Verweistypen 85
virtual 192
virtuelle Methoden 182
W
Wahrheitswerte 52
Währung
Ausgabe 64
WaitHandle
WaitOne() 417
Wertetypen 85
Größe 111
Wertzuweisung 56, 61
Wertzuweisung (Operator) 105
where 223
while 133, 136
Wildcard 259
Windows Forms 425, 427, 505, 560
Baukastensystem 455
Bibliothek 427
Container-Controls 456
Designer 471
Dialoge 456
Drucken 542
Fenster 425
Formulare 427
Grundgerüst für Programme 428
Koordinatensystem 450
Menüs 497
Namensraum 427
Symbolleisten 499
Visual C# 2005 Express 460
Zeitgeber 501
Windows-Anwendungen
Grundgerüst 428
Index
595
596
WinForms 560
WriteLine() 41, 62, 225
XML-Dokumentation 367
XPath 375
X
XML 367
Dokumentaufbau 368
Root-Element, Wurzel 369
Z
Zeichenketten 41, 53, 245
Zeitscheibe 390
Index