Click here to load reader

Visual C# 2008 Kompendium - …7 Inhalt Inhalt Vorwort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

  • View
    0

  • Download
    0

Embed Size (px)

Text of Visual C# 2008 Kompendium - …7 Inhalt Inhalt Vorwort. . . . . . . . . . . . . . . . . . . . . . ....

  • 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, IEnumerator und IEnumerator . . . . . . . . . . . . 381

    ICollection und ICollection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382

    IList und IList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

    IDictionary und IDictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 . . . . . . . . . . . . . . . . . . . . . . . . . 396Erzeugen und Füllen einer List-Auflistung . . . . . . . . . . . . . . . . . . . . . . . . . 399

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

    Durchgehen einer List-Auflistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

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

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

    7.7 Suchen in Auflistungen (am Beispiel der List-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-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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

    Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423

    Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424

    HashSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425

    LinkedList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428

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

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

    7.12 Individualisierbare Auflistungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434

    KeyedCollection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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

    Visual C# 2008 Kompendium - Windows-Programmierung mit dem.NET Framework 3.5InhaltVorwortTeil 1 GrundlagenKapitel 1 Einführung1.1 Zum BuchDie ZielgruppeDer Inhalt dieses BuchsDer Inhalt der Buch-DVDDer Buch-BlogTypografische Konventionen

    1.2 Das Glossar1.3 Die Installation von Visual Studio 2008 und der Express-EditionenDie Visual-Studio-2008-EditionenBetriebssystem und SpeicheranforderungenVorinstallationenDie Installation der Express-EditionenDie Installation von Visual Studio 2008Weitere hilfreiche InstallationenDer erste Start von Visual Studio 2008

    1.4 Wie erhalten Sie Hilfe zu Problemen?Die .NET Framework-DokumentationDie BeispieleCodebooks und KochbücherSuchen im InternetWichtige .NET-Websites

    1.5 Wichtige BegriffeObjekte und KlassenEreignisorientiertes ProgrammierenSchnittstellenZeichencodierung, Unicode, UCS-2, UCS