7

Inha

lt

Inhalt

Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Teil 1 Grundlagen 33

Kapitel 1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

1.1 Zum Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35Die Zielgruppe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Der Inhalt dieses Buchs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Der Inhalt der Buch-DVD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

Der Buch-Blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

Typografische Konventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

1.2 Das Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

1.3 Die Installation von Visual Studio 2008 und der Express-Editionen . . . . . . . . . 46Die Visual-Studio-2008-Editionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

Betriebssystem und Speicheranforderungen. . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Vorinstallationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Die Installation der Express-Editionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Die Installation von Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Weitere hilfreiche Installationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Der erste Start von Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

1.4 Wie erhalten Sie Hilfe zu Problemen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52Die .NET Framework-Dokumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Die Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Codebooks und Kochbücher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Suchen im Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Wichtige .NET-Websites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

1.5 Wichtige Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Objekte und Klassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Ereignisorientiertes Programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Inhalt

8

Zeichencodierung, Unicode, UCS-2, UCS-4, UTF-8, UTF-16, UTF-32 . . . . . . . . . . . . . 62

XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

1.6 Das .NET Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67Was ist .NET? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Was ist das .NET Framework? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

CIL-Code und der Just-In-Time-Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

Die Common Language Runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Der Garbage Collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Die Klassenbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Die Tools des .NET Framework und des Microsoft Windows SDK für das .NET Framework 73

1.7 Die Möglichkeiten von .NET-Programmen . . . . . . . . . . . . . . . . . . . . . . . . . . 75»Normale« Windows-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Komponentenbasierte Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Client/Server-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Webanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Datenbankzugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Anwendungen für mobile Geräte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

1.8 Typen, Namensräume, Assemblys und Module . . . . . . . . . . . . . . . . . . . . . . . 77Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

Assemblys und Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

Assemblys mit und ohne starkem Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Der Global Assembly Cache (GAC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Referenzierung von Assemblys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

Versionsverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

Verwaltung der Zugriffsrechte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

1.9 Der .NET-Reflector: Ein wichtiges Tool zur Erforschung von Assemblys . . . . . . . 85

Kapitel 2 Einführung in die Arbeit mit Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . 87

2.1 Die (wichtigen) C#-Projekttypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

2.2 Projekte und Projektmappen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

2.3 Der Start von Visual Studio und das Erzeugen bzw. Öffnen von Projekten. . . . . 91

2.4 Einstellung der Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

2.5 Die wichtigen Fenster der IDE, erläutert an einem einfachen Beispiel . . . . . . . 95Positionierung der Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Der Projektmappen-Explorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Die Klassenansicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

Der Code-/Designer-Bereich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

Inha

lt

9

Die Toolbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

Der Formular-Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

Das Eigenschaftenfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

Der Code-Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

IntelliSense . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Testen der Beispielanwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

2.6 Weitere wichtige Fenster der IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106Die dynamische Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

Die Aufgabenliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

Der Objektbrowser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

2.7 Kompilieren und Ausführen einer Projektmappe . . . . . . . . . . . . . . . . . . . . . 108Kompilieren einer Projektmappe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

Projektmappen ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

2.8 Entwicklung einer einfachen Windows-Anwendung . . . . . . . . . . . . . . . . . . . 111Das Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Das Formular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Die Programmierung in einer ersten Version . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Die Programmierung in einer fehlerfreien und benutzerfreundlichen Version . . . . . . 114

Verwenden von anderen Ereignissen am Beispiel eines Längenumrechners . . . . . . . 116

2.9 Entwicklung einer Konsolenanwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . 119Programmierung an der Konsole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

Testen von Konsolenanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

2.10 Grundlagen zum Debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122Kompilierfehler beseitigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

Ausnahmen debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

Debuggen logischer Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

2.11 Grundlagen zum Verteilen einer Anwendung . . . . . . . . . . . . . . . . . . . . . . . . 126

2.12 Optionen der Entwicklungsumgebung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

2.13 Projekteigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

2.14 Weitere Features von Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128Lesezeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Quellcode-Verknüpfungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Codeausschnitte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

Codeausschnitte in der Toolbox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Wichtige weitere Features des Code-Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Makros und Add-Ins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

Inhalt

10

Server-Explorer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

Editoren für XML, HTML, CSS, Ressourcen, Bitmaps, Cursor und Icons. . . . . . . . . . . . 133

Suchen mit Ergebnisliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

Inkrementelle Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

Flexible Suche mit regulären Ausdrücken und Platzhaltern . . . . . . . . . . . . . . . . . 133

Der Zwischenablagering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

Eigene Vorlagen für Projekte und Projekt-Elemente . . . . . . . . . . . . . . . . . . . . . . 134

2.15 Kompilieren ohne Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135Der Kommandozeilencompiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

SharpDevelop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

2.16 Neues in Visual Studio 2008 und in den neuen Express-Editionen . . . . . . . . . . 137Neue Projekttypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Neue Features für die Arbeit mit Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

Neues im Code-Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

Sonstige Neuerungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

Kapitel 3 Die Sprache C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

3.1 Die Grundlage einer C#-(Windows-)Anwendung . . . . . . . . . . . . . . . . . . . . . 141Konsolenanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

Windows.Forms-Windows-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

3.2 Assemblys und Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

3.3 Bezeichner und Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

3.4 Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147Elementare Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

Anweisungsblöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

Sichere und unsichere Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Der Aufruf von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

3.5 (Daten)Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155Typsicherheit und der Typ Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Wert- und Referenztypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

Standardwerte der verschiedenen Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

Generische Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

Nullables: Werttypen mit der Möglichkeit nichts (null) zu speichern . . . . . . . . . . . . 167

Freigeben von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

Der Typ String als Ausnahme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Übersicht über die Standardtypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Instanzmethoden der Standardtypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Inha

lt

11

Klassenmethoden und -eigenschaften der Standardtypen. . . . . . . . . . . . . . . . . . 173

Integer-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Fließkommatypen und der Typ decimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Über- und Unterläufe und spezielle Werte. . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

Datumswerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

Zeichen und Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Der Typ Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

Konvertierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

Aufzählungen (Enumerationen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

3.6 Variablen und Konstanten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Die Deklaration von Variablen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

Array-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

Implizit typisierte lokale Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

3.7 Namensrichtlinien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

3.8 Ausdrücke und Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201Der Typ eines Ausdrucks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

Arithmetische Ausdrücke und Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

Bitoperationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

Vergleiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

?:, ??, typeof, is, as, sizeof und =>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

3.9 Verzweigungen und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Die if-Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

Die switch-Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

Die do-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

Die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

Die foreach-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

3.10 Präprozessor-Direktiven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

Kapitel 4 Grundlegende OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

4.1 Klassen und Strukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231Die Unterschiede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Die Deklaration von Klassen und Strukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

4.2 Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

4.3 Kommentieren der Elemente eines Typs . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

Inhalt

12

4.4 Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239Die Deklaration von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

Der this-Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

Überladene Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

ref- und out-Argumente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

Variable Argumente mit params . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

Rekursive Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

4.5 Eigenschaften: Kapselung von Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250Kapselung in Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

Schreibgeschützte Felder und Eigenschaften. . . . . . . . . . . . . . . . . . . . . . . . . . . 254

Eigenschaften mit unterschiedlichen Gültigkeitsbereichen für das Schreiben unddas Lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

Automatisch implementierte Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

Lesegeschützte Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Konstante Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

4.6 Der Gültigkeitsbereich von Klassen, Strukturen und deren Elementen . . . . . . . 259

4.7 Anonyme Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

4.8 Indexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

4.9 Konstruktoren, Finalisierer, Dispose und using. . . . . . . . . . . . . . . . . . . . . . . 266Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

Finalisierer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

Die Close- und die Dispose-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

4.10 Statische Klassenmember und statische Klassen . . . . . . . . . . . . . . . . . . . . . . 273Statische Felder und Eigenschaften (Klasseneigenschaften) . . . . . . . . . . . . . . . . . 273

Statische Klassen: Globale Daten in statischen Eigenschaften . . . . . . . . . . . . . . . . 275

Statische Methoden (Klassenmethoden) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

Statische Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

4.11 Organisieren von Typelementen mit Hilfe von Regionen . . . . . . . . . . . . . . . . 278

Kapitel 5 Weiterführende OOP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

5.1 Partielle Klassen, Strukturen (und Schnittstellen) . . . . . . . . . . . . . . . . . . . . . 281

5.2 Verschachtelte Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

5.3 Vererbung und Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284Ableiten von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

Erweitern von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

Neudefinieren von Methoden und Eigenschaften und Zugriff auf geerbte Elemente . . 288

Polymorphismus, virtuelle Methoden und virtuelle Eigenschaften . . . . . . . . . . . . . 292

Inha

lt

13

Polymorphismus extrem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

Vererbung von Konstruktoren und Finalisierern . . . . . . . . . . . . . . . . . . . . . . . . 298

5.4 Abstrakte Klassen, Eigenschaften und Methoden . . . . . . . . . . . . . . . . . . . . . 299

5.5 Versiegelte Klassen und Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

5.6 Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303Entwurfsrichtlinien für Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

Schnittstellen deklarieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

Schnittstellen implizit implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Explizite Implementierung der Member einer Schnittstelle . . . . . . . . . . . . . . . . . . 307

Mit Schnittstellen arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

Polymorphismus über Schnittstellen im Vergleich zu Polymorphismus über Vererbung 310

Schnittstellenelemente überschreiben und neu definieren . . . . . . . . . . . . . . . . . 310

5.7 Operatoren für eigene Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312Unäre und binäre Operatoren überladen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

Operatoren für Konvertierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

5.8 Wichtige Methoden für eigene Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

5.9 Delegaten, anonyme Methoden und Lambda-Ausdrücke . . . . . . . . . . . . . . . . 320Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Anonyme Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

Vordefinierte Delegaten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

Lambda-Ausdrücke für Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

Kovarianz und Kontravarianz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326

Multicast-Delegaten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

Delegaten im Vergleich zu Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

5.10 Benachrichtigung des Aufrufers über Ereignisse und partielle Methoden . . . . . 329Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

Partielle Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

Der Unterschied zwischen Delegaten, Ereignissen und partiellen Methoden . . . . . . . 337

5.11 Klassenbibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337Klassenbibliotheken entwickeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

Klassenbibliotheken referenzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

Kapitel 6 OOP-Specials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341

6.1 Erweiterungsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341Erweiterungsmethoden und Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . . . 344

Erweiterungsmethoden für Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344

Inhalt

14

6.2 Generische Typen und Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345Generische Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

Generische Typen im Vergleich zu normalen Typen . . . . . . . . . . . . . . . . . . . . . . 347

Ableiten von generischen Klassen und Schnittstellen . . . . . . . . . . . . . . . . . . . . . 348

Generische Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

Automatischer Typrückschluss. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

Typparameter einschränken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

Das default-Schlüsselwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

Generische Schnittstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

Generische Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354

6.3 Lambda-Ausdrücke und Ausdrucksbäume . . . . . . . . . . . . . . . . . . . . . . . . . . 356Lambda-Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

Ausdrucksbäume. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

6.4 Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366Vordefinierte Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

Eigene Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370

Kapitel 7 Arrays und Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373

7.1 Grundsätzliche Unterschiede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

Assoziative Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375

Spezielle Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

Individualisierbare Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

7.2 Übersicht über die aktuellen Auflistungen (inkl. Performance-Vergleich) . . . . . 376Merkmale und Performance der aktuellen Auflistungen . . . . . . . . . . . . . . . . . . . 376

Das Ergebnis meines Performance-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379

7.3 Die Schnittstellen der Arrays und Auflistungen . . . . . . . . . . . . . . . . . . . . . . . 380IEnumerable, IEnumerable<T>, IEnumerator und IEnumerator<T> . . . . . . . . . . . . 381

ICollection und ICollection<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382

IList und IList<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

IDictionary und IDictionary<TKey, TValue> . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384

7.4 Eigene Implementierung eines Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

7.5 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389Arrays erzeugen und verwenden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

Mehrdimensionale Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

Arrays initialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

Implizit typisierte Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

Inha

lt

15

Arrays aus Arrays (Jagged Arrays) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

Zuweisungen von Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393

Methoden und Eigenschaften eines Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394

7.6 Die »normale«, aktuelle Auflistung List<T> . . . . . . . . . . . . . . . . . . . . . . . . . 396Erzeugen und Füllen einer List<T>-Auflistung . . . . . . . . . . . . . . . . . . . . . . . . . 399

Zugriff auf die verwalteten Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

Durchgehen einer List<T>-Auflistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

Entfernen von Objekten aus der Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

Sortieren einer Auflistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

7.7 Suchen in Auflistungen (am Beispiel der List<T>-Auflistung) . . . . . . . . . . . . . 405Suchen mit IndexOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406

Eigene sequenzielle Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406

Suchen mit BinarySearch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407

Suchen mehrerer Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407

Prädikatbasierte Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408

Ein Performance-Vergleich. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410

7.8 Bearbeiten aller Objekte eines Arrays oder einer List<T>-Auflistung mit ForEach 411

7.9 Optimierung einer Auflistung mit vielen Objekten . . . . . . . . . . . . . . . . . . . . 412

7.10 Aktuelle assoziative Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413Der Schlüssel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414

Erzeugen und Füllen einer assoziativen Auflistung. . . . . . . . . . . . . . . . . . . . . . . 415

Zugriff auf die verwalteten Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Durchgehen der verwalteten Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418

Entfernen von Objekten aus der Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420

Assoziative Auflistungen mit speziellen Schlüssel-Vergleichsobjekten . . . . . . . . . . . 421

7.11 Spezielle aktuelle Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422ReadOnlyCollection<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

Queue<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423

Stack<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424

HashSet<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425

LinkedList<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428

BitArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429

BitVector32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431

7.12 Individualisierbare Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434Collection<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434

KeyedCollection<TKey, TItem> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435

7.13 Übersicht über die weniger interessanten, alten Auflistungen des .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437

Inhalt

16

Kapitel 8 Grundlegende Programmiertechniken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441

8.1 Arbeiten mit Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441Die Standard-Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442

Das Ausnahmeprinzip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

Werfen einer Ausnahme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446

Direktes Abfangen von Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448

Weiterwerfen einer Ausnahme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450

Auswerten innerer Ausnahmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452

Der Stack-Trace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454

Schachteln von Ausnahmebehandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

Ignorieren von Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456

Der finally-Block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456

Globale Ausnahmebehandlung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458

8.2 Arbeiten mit Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460Strings vergleichen und Teilstrings suchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464

Teilstrings extrahieren, Strings kürzen und auffüllen . . . . . . . . . . . . . . . . . . . . . 466

Teilstrings ersetzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466

Strings einfügen und löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467

Strings in Groß- und Kleinschreibung umwandeln . . . . . . . . . . . . . . . . . . . . . . 467

Trennen und Zusammensetzen von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 468

Die StringBuilder-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469

8.3 Reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472Das Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473

Die Musterzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474

Strings auf ein Muster testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478

Kompilieren eines regulären Ausdrucks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479

Performancevergleich der statischen mit den Instanzmethoden und mit vorkompilierten Assemblys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481

Fundstellen auswerten: Das Match-Objekt. . . . . . . . . . . . . . . . . . . . . . . . . . . . 482

Festlegen, dass ein String mit einem Muster beginnen und/oder enden muss . . . . . . 483

In mehrzeiligen Strings suchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483

Groß- und Kleinschreibung ignorieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484

Gruppierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484

Faule Quantifizierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488

Rückreferenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489

Ersetzen von Teilstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

Flexibles Ersetzen über einen Match-Evaluator . . . . . . . . . . . . . . . . . . . . . . . . . 492

Strings splitten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492

Einige Beispiele. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492

Inha

lt

17

8.4 Formatierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493Zahlformatierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494

Datumsformatierungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497

Kulturspezifisches Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500

8.5 Eingaben überprüfen und parsen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501Eingaben überprüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501

Parsen von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503

Parsen spezifischer Datumsangaben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

8.6 Arbeiten mit Datumswerten und Zeitspannen . . . . . . . . . . . . . . . . . . . . . . . 506Der Offset zur UTC-Zeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506

Wichtige Eigenschaften und Methoden der DateTimeOffset-Struktur. . . . . . . . . . . . 508

Grundlegende Arbeit mit DateTimeOffset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510

Konvertieren nach DateTime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510

Datumswerte vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511

Mit Zeitspannen arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512

8.7 Mathematische Berechnungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513Übersicht über die Methoden und Eigenschaften der Math-Klasse . . . . . . . . . . . . . 513

Winkelberechnungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516

Zahlen runden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520

8.8 Meldungen mit Hilfe der MessageBox-Klasse ausgeben . . . . . . . . . . . . . . . . . 521

8.9 Wichtige Diagnose-Hilfsmittel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526

8.10 Auswerten von Befehlszeilenargumenten . . . . . . . . . . . . . . . . . . . . . . . . . . 527

8.11 Dokumentation der Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529Die Elemente der C#-Dokumentationskommentare . . . . . . . . . . . . . . . . . . . . . . 529

Erstellen der Dokumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

8.12 Umgang mit dem Garbage Collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538Die Arbeitsweise des Garbage Collectors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

Vorkehrungen zur Optimierung des Speicherverbrauchs . . . . . . . . . . . . . . . . . . . 540

Manuelles Aufrufen des GC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540

Kapitel 9 Fehler debuggen, testen und protokollieren . . . . . . . . . . . . . . . . . . . . . . . . 543

9.1 Fehler suchen und beseitigen (Debugging). . . . . . . . . . . . . . . . . . . . . . . . . . 543Voraussetzungen und Grundeinstellungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 543

Anhalten des Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545

Basis-Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547

Die Debugging-Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550

Bedingte Haltepunkte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554

Haltepunkte mit Trefferanzahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555

Inhalt

18

Weitere Features von Haltepunkten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555

Debuggen des fehlerhaften Setzens von Eigenschaften und Feldern . . . . . . . . . . . . 555

Haltepunkte mit Debugger.Break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556

Debuggen bei vorhandener Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . 557

Debuggingausgaben mit Debug.Print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558

Annahmen mit Debug.Assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558

Debugging des .NET Framework-Quellcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . 560

9.2 Automatisches Testen mit Unit-Tests. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564Grundlagen zu Unit-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564

Unit-Tests in Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565

Das Testergebnis und die Testkonfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . 570

Debuggen von Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571

Initialisieren von Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571

Testreihen und die Test-Reihenfolge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572

Der Test-Kontext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572

Datengetriebene Tests. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573

9.3 Protokollieren während der Ausführung einer Anwendung . . . . . . . . . . . . . . 575Protokollieren mit TraceSource . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575

Flexibles, konfigurierbares Protokollieren mit log4net . . . . . . . . . . . . . . . . . . . . 585

Kapitel 10 Arbeiten mit Dateien, Ordnern und Streams. . . . . . . . . . . . . . . . . . . . . . . . . 599

10.1 Mit dem Dateisystem arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600Dateioperationen über File und FileInfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600

Ordneroperationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607

Ermitteln der Pfade von Systemordnern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612

Pfade über die Path-Klasse bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614

Laufwerkinformationen über die Klasse DriveInfo . . . . . . . . . . . . . . . . . . . . . . . 616

Überwachen des Dateisystems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618

10.2 Einführung in die Arbeit mit Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620Das Stream-Konzept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620

Die Methoden und Eigenschaften der Basisklasse Stream. . . . . . . . . . . . . . . . . . . 621

MemoryStream: Ein Beispiel für das Stream-Konzept . . . . . . . . . . . . . . . . . . . . . 623

Die Standard-Streams. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623

Stream-Adapter und Dekorator-Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624

Das richtige Schließen und der interne Puffer . . . . . . . . . . . . . . . . . . . . . . . . . . 625

StringWriter und StringReader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628

10.3 Dateien binär über eine FileStream-Instanz lesen und schreiben . . . . . . . . . . 630

10.4 Spezielles binäres Schreiben und Lesen über BinaryWriter und BinaryReader . . 633

Inha

lt

19

10.5 Textdateien lesen und schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634

10.6 Daten komprimieren und komprimierte Daten entpacken . . . . . . . . . . . . . . . 636

10.7 Richtlinien zum Speichern von Daten im Dateisystem . . . . . . . . . . . . . . . . . . 641

10.8 Arbeiten mit isoliertem Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642Grundlagen von isoliertem Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643

Schreiben und Lesen von isoliertem Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . 645

Auflisten der Dateien in einem isolierten Speicher . . . . . . . . . . . . . . . . . . . . . . . 646

Löschen von Ordnern und Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647

Kapitel 11 LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649

11.1 Grundlegendes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649Grundlegende Abfragen über die LINQ-Erweiterungsmethoden . . . . . . . . . . . . . . 651

Sequenzen und Einzeldaten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

Die Aufrufkette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653

Die Originaldaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653

C#-Abfrageausdrücke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653

Gemischte Verwendung von Abfrageausdrücken und Erweiterungsmethoden . . . . . 655

Wann Abfrageausdrücke und wann Erweiterungsmethoden? . . . . . . . . . . . . . . . . 656

Aufgeschobene Ausführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657

Lokale und interpretierte Abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 660

Performance-Überlegungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662

11.2 Die LINQ-Erweiterungsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663Grundlagen zu der in den folgenden Abschnitten verwendeten Syntaxbeschreibung der LINQ-Erweiterungsmethoden . . . . . . . . . . . . . . . . . . . . 666

Einschränken mit Where . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

Sortieren mit OrderBy, OrderByDescending, ThenBy und ThenByDescending . . . . . . . 668

Projektionen mit Select . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669

Gruppierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671

Verknüpfen von Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679

Methoden zur Ermittlung einzelner Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . 686

Aggregat-Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690

Methoden zur Ermittlung, ob Objekte in einer Sequenz enthalten sind . . . . . . . . . . 694

Spezielle Filter-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696

Konvertierungsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698

Erzeugungsmethoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699

Mengen-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699

11.3 Komplexe Abfragen mit into, let und mehreren from-Klauseln. . . . . . . . . . . . 703Das into-Schlüsselwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703

Abfragen schachteln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705

Inhalt

20

Das let-Schlüsselwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705

Ein Performance-Vergleich. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706

Abfragen mit mehreren from-Klauseln: Kreuzprodukt-Abfragen und spezielle Abfragen wie Ungleichheits-Verknüpfungen . . . . . . . . . . . . . . . . . . . . 707

Unterabfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712

11.4 Einige Tipps und Tricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714Progressive und dynamische Abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714

Ungleichheits-Verknüpfungen (Non-Equi Joins) . . . . . . . . . . . . . . . . . . . . . . . . 716

Kreuzprodukt-Verknüpfungen (Cross Joins) . . . . . . . . . . . . . . . . . . . . . . . . . . . 718

Kommaseparierte Dateien (CSV-Dateien) verarbeiten . . . . . . . . . . . . . . . . . . . . . 719

Teil 2 Anwendungen entwickeln 721

Kapitel 12 WPF-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723

12.1 WPF versus Windows.Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724Klassische Windows-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724

WPF-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725

Die wesentlichen Unterschiede zwischen Windows.Forms- und WPF-Anwendungen . 726

WPF oder Windows.Forms? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729

12.2 Die Möglichkeiten, die Sie mit WPF haben . . . . . . . . . . . . . . . . . . . . . . . . . . 729

12.3 WPF-Anwendungen in Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 730Das WPF-Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 730

Grundlagen zum Erzeugen eines neuen WPF-Projekts . . . . . . . . . . . . . . . . . . . . 732

Einstellung der Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734

Die Gestaltung der Oberfläche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737

Die Programmierung des Beispiels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739

Debuggen von WPF-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741

Die Architektur einer mit Visual Studio erzeugten WPF-Anwendung . . . . . . . . . . . . 745

12.4 XAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748Grundaufbau und Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748

Parsen und Kompilieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751

Objekterzeugung und Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752

Markuperweiterungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756

Die XAML-Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760

XAML mit integriertem Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761

12.5 Die grundlegenden WPF-Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761Der prinzipielle Unterschied zwischen WPF-Fenstern und WPF-Seiten . . . . . . . . . . 762

Ressourcen, Stile, Vorlagen, Dekoratoren, Skins und Themen . . . . . . . . . . . . . . . . 762

Inha

lt

21

Logische und visuelle Bäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765

Abhängigkeitseigenschaften. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 768

Angefügte Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776

Geroutete Ereignisse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777

Angefügte Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781

Die grundlegende WPF-Klassenhierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782

Kapitel 13 WPF-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785

13.1 Grundlegendes zur Anwendungsentwicklung unter WPF . . . . . . . . . . . . . . . . 785Die WPF-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786

Herunterfahren einer Anwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788

Standarddialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790

Systemparameter auslesen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 796

13.2 Grundlegendes zur Arbeit mit Fenstern und Steuerelementen. . . . . . . . . . . . . 797Die Einheit von Positions- und Größenangaben . . . . . . . . . . . . . . . . . . . . . . . . 797

Farbangaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 799

Der Vorder- und Hintergrund eines Fensters oder Steuerelements: Die Brush-Klasse . 800

Schriftangaben: Verschiedene Schriftart-Klassen . . . . . . . . . . . . . . . . . . . . . . . . 803

Wichtige allgemeine Eigenschaften der WPF-Fenster und Steuerelemente . . . . . . . . 804

Die wichtigen allgemeinen Ereignisse der Steuerelemente und Fenster . . . . . . . . . . 806

Die wichtigen allgemeinen Methoden der Steuerelemente und Fenster. . . . . . . . . . 809

13.3 Der Umgang mit WPF-Fenstern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 810Die wichtigen Eigenschaften eines Fensters . . . . . . . . . . . . . . . . . . . . . . . . . . . 810

Die Tabulatorreihenfolge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814

(Modales und unmodales) Öffnen weiterer Fenster . . . . . . . . . . . . . . . . . . . . . . 814

Schließen eines Fensters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818

Reaktion auf das Schließen eines Fensters . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818

Dialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819

Initialisieren eines Fensters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822

Tipps und Tricks zu Fenstern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822

13.4 Die WPF-Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 824Die Basisklassen der Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825

Übersicht über die Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825

Der Inhalt eines Steuerelements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 827

Die Größe und Position von Steuerelementen . . . . . . . . . . . . . . . . . . . . . . . . . . 830

Inhalts-Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835

Listen-Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842

Bereichssteuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849

Text-Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851

Inhalt

22

Menüs, Symbolleisten und Statuszeilen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854

Layout-Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858

13.5 Einige abschließende Tipps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864Abfrage der Tastatur außerhalb von Tastaturereignissen . . . . . . . . . . . . . . . . . . . 865

Umgang mit der Zwischenablage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865

Kapitel 14 Wichtige WPF-Techniken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867

14.1 Ressourcen in WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868Die unterschiedlichen Ressourcenarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869

Binäre Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869

Ressourcenangaben: Normale URIs und Paket-URIs . . . . . . . . . . . . . . . . . . . . . . 871

Wörterbuch-Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 877

14.2 Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887Was ist ein Befehl?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887

Ein eigener Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887

Verknüpfen eines Befehls mit WPF-Steuerelementen . . . . . . . . . . . . . . . . . . . . . 890

Vordefinierte Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892

Vordefinierte Befehle mit Steuerelementen einsetzen . . . . . . . . . . . . . . . . . . . . . 893

Befehlsbindungen an Ereignishandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 895

Befehlsbindungen für eigene Befehle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896

Verknüpfen von Befehlen mit Tastenkombinationen oder mit der Maus . . . . . . . . . 898

14.3 Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 899Grundlagen zu Triggern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 900

Eigenschaftentrigger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901

Multi-Eigenschaftentrigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902

Datentrigger und Multi-Datentrigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 903

Ereignistrigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 903

14.4 Dekoratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 904

14.5 Stile, Vorlagen, Skins und Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905Stile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905

Vorlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 913

Skins und Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 919

14.6 Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922Einfache Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922

Fehler bei der Datenbindung auswerten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924

Relative Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924

Das Beispiel für die folgenden Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 925

Bindung an Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 926

Inha

lt

23

Der Datenkontext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 928

Datenvorlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 929

Konvertieren der gebundenen Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 930

Nicht besprochene Features der Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . 931

14.7 Einige weitere WPF-Techniken am Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . 932Transformationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 932

Animationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 933

Kapitel 15 Konfiguration, Ressourcen und Lokalisierung. . . . . . . . . . . . . . . . . . . . . . . . 935

15.1 Konfiguration einer Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935Die Basis: machine.config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 936

Die Basis-Konfiguration einer Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . 938

Grundlagen zu anwendungsspezifischen Konfigurationsdaten . . . . . . . . . . . . . . . 940

Konfigurationsdaten im appSettings-Element. . . . . . . . . . . . . . . . . . . . . . . . . . 940

Konfiguration einer Anwendung mit den Standard-Features von Visual Studio . . . . . 941

Verbindungszeichenfolgen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 946

Nicht näher besprochene Konfigurations-Features. . . . . . . . . . . . . . . . . . . . . . . 947

15.2 Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947Binäre, eingebettete Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 948

.resx-Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 948

15.3 Lokalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953Grundlagen der Lokalisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953

Lokalisierung einer Windows.Forms-Anwendung . . . . . . . . . . . . . . . . . . . . . . . 959

Lokalisierung einer WPF-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 960

Ansätze zu einem Lokalisieren in der Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . 967

Kapitel 16 Windows-Anwendungen verteilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 969

16.1 Vorbereitung der Verteilung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 969Die Version der Anwendung und weitere Assembly-Informationen . . . . . . . . . . . . 969

Die notwendigen Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971

16.2 XCopy-Verteilung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972

16.3 Erstellung eines Setup mit Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . 972Das Setup-Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973

Die Einstellung des Setup-Projekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975

Das Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977

Benutzerdefinierte Aktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979

Weitere Features von Visual-Studio-Setup-Projekten, die hier nicht besprochen werden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 987

Inhalt

24

16.4 ClickOnce-Verteilung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 988Die Basis-Dateien eines ClickOnce-Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 990

Die Rechte einer ClickOnce-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 991

Erstellung eines ClickOnce-Setup mit Visual Studio . . . . . . . . . . . . . . . . . . . . . . . 992

Verteilung und Installation auf einem Webserver . . . . . . . . . . . . . . . . . . . . . . . 998

Aktualisierung einer ClickOnce-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002

Nicht besprochene ClickOnce-Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002

Teil 3 Daten verwalten 1005

Kapitel 17 Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1007

17.1 Grundlagen der Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1007

17.2 Wann welche Serialisierung? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009

17.3 XML-Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009Serialisieren über einen XmlSerializer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1010

Deserialisieren über einen XmlSerializer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1012

Versions-Unterstützung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1012

Steuern der Serialisierung über Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1013

Weitere Beispiele auf der DVD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1014

17.4 Binäre/SOAP-Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015Binäres Serialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015

Das binäre Deserialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017

Attribute für die binäre Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017

Versionierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1018

17.5 Datenvertrag-Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1019Die Definition des Datenvertrags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1019

Die Serialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1021

Die Deserialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022

Objekte binär serialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1023

Datenvertrag-Serialisierung und Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . 1024

Serialisieren von Objekt-Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025

Versionierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1027

Nicht besprochene Features der Datenvertrag-Serialisierer . . . . . . . . . . . . . . . . . . 1029

Kapitel 18 XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031

18.1 Noch nicht behandelte XML-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031Das Document Object Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031

Inha

lt

25

XML-Schema (XSD), XPath und XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035

Die XML-APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1041

18.2 Lesen und Schreiben mit XElement, XDocument und LINQ to XML . . . . . . . . . . . 1041Laden und Parsen von einfachen XML-Dokumenten . . . . . . . . . . . . . . . . . . . . . 1042

Erzeugen eines XML-Dokuments ohne Namensraum . . . . . . . . . . . . . . . . . . . . . 1043

Speichern von Nullwerten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045

Gemischte Inhalte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1046

Serialisieren und Speichern eines X-DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047

Erzeugen von XML-Dokumenten mit Namensraum . . . . . . . . . . . . . . . . . . . . . . 1047

Navigieren in einem XML-Dokument (ohne Namensräume) . . . . . . . . . . . . . . . . . 1050

Navigieren in einem XML-Dokument mit Namensräumen . . . . . . . . . . . . . . . . . . 1054

Lesen von Textinhalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055

Ändern eines XML-Dokuments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057

Die Klasse XDocument. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1060

LINQ to XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1061

Abfragen mit LINQ to XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1061

Erzeugen von XML-Dokumenten über LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065

Transformation von XML-Dokumenten mit LINQ to XML . . . . . . . . . . . . . . . . . . . . 1067

Nicht besprochene Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1069

18.3 Schnelles Lesen und Schreiben mit einem XmlReader bzw. XmlWriter . . . . . . . 1069Lesen über einen XmlReader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1069

Schreiben über einen XmlWriter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1073

18.4 XML-Dokumente über XSD validieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075

Kapitel 19 Datenbanken mit LINQ to SQL bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . 1079

19.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080Der Begriff »Entität«. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080

Die Beispiel-Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080

Übersicht über die Möglichkeiten, in .NET 3.5 Datenbanken zu bearbeiten . . . . . . . . 1084

Einschränkungen von LINQ to SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1086

19.2 Erstellen eines Datenbankmodells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1087Erstellen eines Datenbankmodells mit Visual Studio auf der Basis einer vorhandenen Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1087

Erstellen eines komplett neuen Datenbankmodells mit Visual Studio . . . . . . . . . . . 1089

Das grundlegende Datenbankmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1090

Erste Nachbearbeitung des Datenbankmodells . . . . . . . . . . . . . . . . . . . . . . . . . 1090

Die Einstellungen des Datenkontextes, der Entitäts-Klassen und ihrer Eigenschaften . 1092

Zweite Nachbearbeitung des Datenbankmodells . . . . . . . . . . . . . . . . . . . . . . . . 1094

Die Klassen des Modells und der Datenkontext . . . . . . . . . . . . . . . . . . . . . . . . . 1096

Inhalt

26

Erzeugen des Datenkontextes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1097

Das LINQ-to-SQL-Protokoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099

19.3 Abfragen mit LINQ to SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099Einfache Abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099

Abfragen mit LIKE und dynamische Abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . 1100

Einschränkungen von LINQ to SQL gegenüber LINQ . . . . . . . . . . . . . . . . . . . . . . . 1101

Aufgeschobene Ausführung mit LINQ to SQL und das Erzeugen von SQL . . . . . . . . . . 1102

Auflösen von Beziehungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1103

Abfragen an die Oberfläche binden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105

(Verzicht auf) Verknüpfungen in LINQ to SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . 1106

Gruppierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1108

Die Effizienz der Abfrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1109

Verzögertes Laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1109

Der Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1111

19.4 Bearbeiten von Daten über das Objektmodell. . . . . . . . . . . . . . . . . . . . . . . . 1113Anfügen, Ändern und Löschen von Entitäten . . . . . . . . . . . . . . . . . . . . . . . . . . 1114

Fehlerbehandlung beim Anfügen, Ändern und Löschen . . . . . . . . . . . . . . . . . . . 1119

19.5 Business-Objekt-Modelle oder: Die partiellen Klassen und eine Reaktion auf Datenereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1122

19.6 Transaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1126

19.7 Behandlung von Konflikten beim Aktualisieren . . . . . . . . . . . . . . . . . . . . . . 1128Die Aktualisierungs-Überprüfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1128

Behandeln der ChangeConflictException . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1129

19.8 Wichtige, nicht behandelte Features. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1134

Teil 4 Fortgeschrittene Programmierung 1137

Kapitel 20 Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1139

20.1 Einführung in Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1140Was ist ein Thread? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1140

Was ist Multithreading?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1140

Threads aus technischer Sicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1141

Threadsicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1142

Mögliche Probleme beim Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1142

Wann sollten Sie Multithreading einsetzen? . . . . . . . . . . . . . . . . . . . . . . . . . . . 1144

Nachteile des Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145

Die Möglichkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1146

Inha

lt

27

20.2 Zugriff auf die Benutzeroberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1147

20.3 Asynchrones Ausführen von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1148Die asynchron auszuführende Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1149

Der Delegat für die Methode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1150

Der Callback-Delegat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1150

Der asynchrone Aufruf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1152

Die Prozessorlast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1152

20.4 Einfaches Multithreading mit der BackgroundWorker-Klasse . . . . . . . . . . . . . 1152

20.5 Einfache Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156Threads erzeugen und starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1157

Threads debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1159

Das Ende von Threads signalisieren, Ergebnisse zurückgeben und Argumente einfacher übergeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1160

Die Priorität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163

Threads abbrechen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1164

Ein praxisnahes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1166

20.6 Die ThreadPool-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1173ThreadPool verwenden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1173

Die Anzahl der Threads im Pool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174

Die Arbeitsweise von ThreadPool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174

Die Interne Verwendung der ThreadPool-Klasse . . . . . . . . . . . . . . . . . . . . . . . . 1175

Weitere interessante Features von ThreadPool, die hier nicht näher besprochen werden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175

20.7 Ausnahmen in Threads und beim asynchronen Aufruf von Methoden . . . . . . . 1176

20.8 Das ereignisbasierte asynchrone Entwurfsmuster und asynchrone Methoden . . 1178Das ereignisbasierte asynchrone Entwurfsmuster. . . . . . . . . . . . . . . . . . . . . . . . 1179

Asynchrone Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1181

20.9 Threads synchronisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183Threads blockieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1184

Den Zugriff auf globale Daten und Ressourcen sperren . . . . . . . . . . . . . . . . . . . . 1186

Prozessübergreifendes Sperren mit einem Mutex . . . . . . . . . . . . . . . . . . . . . . . . 1193

Signalisierungs-Konstrukte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195

Atomare Anweisungen und die Klasse Interlocked . . . . . . . . . . . . . . . . . . . . . . . 1202

20.10 Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1203

20.11 Weitere interessante Themen beim Multithreading . . . . . . . . . . . . . . . . . . . . 1204

Inhalt

28

Kapitel 21 Der Aufruf von API-Funktionen und das Arbeiten mit COM-Komponenten . . . . 1205

21.1 Das Windows-API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1206Der Aufruf von API-Funktionen über PInvoke . . . . . . . . . . . . . . . . . . . . . . . . . . 1206

Umsetzen von Datentypen (Marshalling) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1208

Die .NET-Entsprechungen der API-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1209

Boolesche Argumente, Felder und Rückgabewerte. . . . . . . . . . . . . . . . . . . . . . . 1210

Strings übergeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1211

Die Rückgabe von Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213

Referenzargumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1214

Die Übergabe von Strukturen und feste Strings . . . . . . . . . . . . . . . . . . . . . . . . . 1215

API-Konstanten-Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1216

Umgehen mit API-Fehlern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1217

Umsetzen von API-Fehlercodes in passende Fehlerbeschreibungen . . . . . . . . . . . . 1218

21.2 Arbeiten mit COM-Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1220COM-Komponenten mit früher Bindung verwenden . . . . . . . . . . . . . . . . . . . . . 1221

COM-Komponenten mit später Bindung verwenden. . . . . . . . . . . . . . . . . . . . . . 1224

Kapitel 22 Assemblys, Reflektion und Anwendungsdomänen. . . . . . . . . . . . . . . . . . . . . 1229

22.1 Wichtige weitere Möglichkeiten beim Umgang mit Assemblys. . . . . . . . . . . . . 1229Das Signieren und der Name einer Assembly . . . . . . . . . . . . . . . . . . . . . . . . . . 1230

Vorkompilieren von Assemblys in den nativen Abbild-Cache . . . . . . . . . . . . . . . . 1235

Assemblys, die nicht im Anwendungsordner direkt verwaltet werden . . . . . . . . . . 1237

22.2 Reflektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1237Evaluieren von Typen und Assemblys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1238

Dynamisches Instanzieren und Verwenden von Typen . . . . . . . . . . . . . . . . . . . . 1241

Dynamisches Erzeugen von Typen und Assemblys . . . . . . . . . . . . . . . . . . . . . . . 1246

22.3 Anwendungsdomänen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1248Der Sinn von Anwendungsdomänen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1249

Anwendungsdomänen erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1250

Ausführen einer ausführbaren Assembly in der Anwendungsdomäne . . . . . . . . . . 1250

Entladen von Anwendungsdomänen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1251

Ausführen von eigenem Programmcode in einer separaten Anwendungsdomäne . . . 1251

Dynamisches Erzeugen und Verwenden von Typen einer Assembly in einer separaten Anwendungsdomäne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1252

Datenaustausch zwischen Anwendungsdomänen . . . . . . . . . . . . . . . . . . . . . . . 1253

Optimieren des Ladeverhaltens von Assemblys . . . . . . . . . . . . . . . . . . . . . . . . . 1255

Weitere Features, die hier nicht näher besprochen werden . . . . . . . . . . . . . . . . . 1255

Inha

lt

29

Kapitel 23 Sicherheitsgrundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1257

23.1 Codezugriffssicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1258Die Arbeitsweise der Codezugriffssicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . 1258

Die Administration der Codezugriffssicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . 1260

Codezugriffssicherheit auf Assembly-Ebene . . . . . . . . . . . . . . . . . . . . . . . . . . . 1261

23.2 Verschlüsseln und Entschlüsseln von Daten . . . . . . . . . . . . . . . . . . . . . . . . . 1262Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1262

Windows-Verschlüsselung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1265

Das Ver- und Entschlüsseln von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1266

Hashcodes berechnen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267

Daten symmetrisch verschlüsseln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1270

Daten asymmetrisch verschlüsseln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1274

Digitale Signaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1279

23.3 Das sichere Ende dieses Buchs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1280

Teil 5 Anhang 1281

Kapitel A Glossar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283

Kapitel B Die ersten 255 Zeichen des Unicode-Zeichensatzes. . . . . . . . . . . . . . . . . . . . . 1299

Kapitel C Meine Namenskonvention für Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . 1301

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1305