C#与.NET 3.0
Teil 1 nnn Einführung in C# und die .NET-Plattform
nKAPITEL 1 Die Philosophie von .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Den bisherigen Stand der Dinge verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Die .NET-Lösung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Einführung in die Bausteine der .NET-Plattform (CLR, CTS,
und CLS). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Zusätzliche .NET-fähige Programmiersprachen. . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Ein Überblick über .NET-Assemblys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Das Common Type System verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Die Common Language Specification verstehen. . . . . . . . . . . . . . . . . . . . . . 20
Die Common Language Runtime verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . 22
Die Assembly-/Namespace-/Typ-Unterscheidung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Erkunden einer Assembly mit ildasm.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Erkundung einer Baugruppe mit Lutz Roeders Reflektor. . . . . . . . . . . . . . . . . . . . . . 31
Bereitstellen der .NET-Runtime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Die Plattformunabhängigkeit von .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
nKAPITEL 2 Erstellen von C#-Anwendungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Die Rolle des .NET Framework 3.5 SDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Erstellen von C#-Anwendungen mit csc.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Erstellen von .NET-Anwendungen mit TextPad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Erstellen von .NET-Anwendungen mit Notepad++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Erstellen von .NET-Anwendungen mit SharpDevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Erstellen von .NET-Anwendungen mit Visual C# 2008 Express. . . . . . . . . . . . . . . . . . 50
Erstellen von .NET-Anwendungen mit Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . 52
Ein Teilkatalog zusätzlicher .NET-Entwicklungstools. . . . . . . . . . . . . . . . . . . . 64
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
iv
Teil 2 nnn Kern-C#-Programmierkonstrukte
nKAPITEL 3 Kern-C#-Programmierkonstrukte, Teil I . . . . . . . . . . . . . . . . . . . . . . . . . 69
Die Anatomie eines einfachen C#-Programms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Eine interessante Randbemerkung: Einige weitere Mitglieder der
System.Environment-Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Die System.Console-Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Systemdatentypen und C#-Kurznotation. . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Den System.String-Typ verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Eingrenzen und Erweitern von Datentypkonvertierungen. . . . . . . . . . . . . . . . . . . . . . . . . . 95
C#-Iterationskonstrukte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Entscheidungskonstrukte und die relationalen/Gleichheitsoperatoren. . . . . . . . . . . . . . . . . 102
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
nKAPITEL 4 Kern-C#-Programmierkonstrukte, Teil II . . . . . . . . . . . . . . . . . . . . . . . . 107
Methoden und Parametermodifikatoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Grundlegendes zur Mitgliederüberladung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Array-Manipulation in C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Den Enum-Typ verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Den Strukturtyp verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Werttypen und Referenztypen verstehen. . . . . . . . . . . . . . . . . . . . . . . . 129
Wert- und Referenztypen: Endgültige Details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Grundlegendes zu C#-Nullable-Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
nKAPITEL 5 Definieren gekapselter Klassentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Einführung in den C#-Klassentyp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Klassenkonstruktoren verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Die Rolle des Schlüsselworts this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Das statische Schlüsselwort verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Definition der Säulen von OOP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
C#-Zugriffsmodifikatoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Die erste Säule: Die Kapselungsdienste von C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Konstante Daten verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Grundlegendes zu schreibgeschützten Feldern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Partielle Typen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
C#-Quellcode über XML dokumentieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Visualisierung der Früchte unserer Arbeit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
nKAPITEL 6 Vererbung und Polymorphismus verstehen. . . . . . . . . . . . . . . . . . 185
Die grundlegenden Mechanismen der Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Überarbeitung von Visual Studio-Klassendiagrammen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Die zweite Säule: Die Einzelheiten der Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Programmierung für Eindämmung/Delegation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
nINHALTE v
vi nINHALTE
Die dritte Säule: Die polymorphe Unterstützung von C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Grundlegendes zu Umwandlungsregeln für Basisklassen/abgeleitete Klassen. . . . . . . . . . . . . . . . . . . 210
Die übergeordnete Masterklasse: System.Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
nKAPITEL 7 Strukturierte Ausnahmebehandlung verstehen. . . . . . . . . . . . . . . . . . . 219
Ode an Fehler, Bugs und Ausnahmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Die Rolle der .NET-Ausnahmebehandlung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Das einfachste mögliche Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Konfigurieren des Status einer Ausnahme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Ausnahmen auf Systemebene (System.SystemException) . . . . . . . . . . . . . . . . . . . . . 230
Ausnahmen auf Anwendungsebene (System.ApplicationException) . . . . . . . . . . . . . . . 231
Mehrere Ausnahmen verarbeiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Der „Endlich“-Block. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Wer wirft was? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Das Ergebnis nicht behandelter Ausnahmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Debuggen nicht behandelter Ausnahmen mit Visual Studio. . . . . . . . . . . . . . . . . . . . 242
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
nKAPITEL 8 Die Lebensdauer von Objekten verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Klassen, Objekte und Referenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Die Grundlagen der Objektlebensdauer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Die Rolle der Anwendungswurzeln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Objektgenerationen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Der System.GC-Typ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Finalisierbare Objekte erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Wegwerfobjekte bauen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Erstellen finalisierbarer und verfügbarer Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Teil 3 nnn Fortgeschrittene C#-Programmierkonstrukte
nKAPITEL 9 Arbeiten mit Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Schnittstellentypen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Benutzerdefinierte Schnittstellen definieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Implementierung einer Schnittstelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Aufrufen von Schnittstellenmitgliedern auf Objektebene. . . . . . . . . . . . . . . . . . . . . . . . . 276
Schnittstellen als Parameter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Schnittstellen als Rückgabewerte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Arrays von Schnittstellentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Implementieren von Schnittstellen mit Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . 282
Auflösen von Namenskonflikten durch explizite Schnittstellenimplementierung. . . . . . . . . . . . . 283
Entwerfen von Schnittstellenhierarchien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Aufzählbare Typen erstellen (IEnumerable und IEnumerator). . . . . . . . . . . . . . . 289
Erstellen klonbarer Objekte (ICloneable) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Vergleichbare Objekte erstellen (IComparable). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Callback-Schnittstellen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
nKAPITEL 10 Sammlungen und Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Die Schnittstellen des System.Collections-Namespace. . . . . . . . . . . . . . . . . . . . . 309
Die Klassentypen von System.Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
System.Collections.Specialized-Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Die Boxing-, Unboxing- und System.Object-Beziehung. . . . . . . . . . . . . . . . . . . 316
Das Problem der Typensicherheit und stark typisierter Sammlungen. . . . . . . . . . . . . . . . . . 319
Der System.Collections.Generic-Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Erstellen benutzerdefinierter generischer Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Generische Strukturen und Klassen erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Erstellen einer benutzerdefinierten generischen Sammlung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
Generische Basisklassen erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Generische Schnittstellen erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
nKAPITEL 11 Delegierte, Ereignisse und Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Den .NET-Delegattyp verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Definieren eines Delegaten in C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Die Basisklassen System.MulticastDelegate und System.Delegate. . . . . . . . . 344
Das einfachste mögliche Delegatenbeispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Nachrüstung des Wagentyps mit Delegierten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
Ein ausführlicheres Beispiel für einen Delegaten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Delegierte Kovarianz verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Generische Delegaten erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
C#-Ereignisse verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Der generische EventHandler-Delegat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Grundlegendes zu anonymen C#-Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Methodengruppenkonvertierungen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Der C# 2008 Lambda-Operator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
nKAPITEL 12 Indexer, Operatoren und Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Indexermethoden verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Verständnis der Operatorüberlastung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Benutzerdefinierte Typkonvertierungen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Arbeiten mit Zeigertypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
C#-Präprozessoranweisungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
nKAPITEL 13 C# 2008-Sprachfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Implizit typisierte lokale Variablen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . 415
Automatische Eigenschaften verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Erweiterungsmethoden verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
nINHALT vii
Partielle Methoden verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Grundlegendes zur Syntax des Objektinitialisierers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Anonyme Typen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
nKAPITEL 14 Eine Einführung in LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Die Rolle von LINQ verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Ein erster Blick auf LINQ-Abfrageausdrücke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
LINQ und generische Sammlungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
LINQ und nicht generische Sammlungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
Die interne Darstellung von LINQ-Abfrageoperatoren. . . . . . . . . . . . . . . . . . . . . 459
Untersuchung der C#-LINQ-Abfrageoperatoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
LINQ-Abfragen: Eine Insel für sich?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
TEIL 4 nnn Programmierung mit .NET-Assemblys
nKAPITEL 15 Einführung in .NET-Assemblys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Definieren benutzerdefinierter Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Die Rolle von .NET-Assemblys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
Das Format einer .NET-Assembly verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . 482
Erstellen und Konsumieren einer Single-File-Assembly. . . . . . . . . . . . . . . . . . . . . . . . . 486
Erstellen und Konsumieren einer Multifile-Assembly. . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Private Versammlungen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Grundlegendes zu freigegebenen Baugruppen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Eine gemeinsam genutzte Assembly konsumieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Konfigurieren freigegebener Baugruppen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Untersuchung der internen Zusammensetzung des GAC. . . . . . . . . . . . . . . . . . . . . . . . 516
Grundlegendes zu Publisher-Richtlinienassemblys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Das -Element verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
Der System.Configuration-Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
Die Maschinenkonfigurationsdatei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
nKAPITEL 16 Typreflexion, späte Bindung und attributbasiert
Programmierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Die Notwendigkeit von Typmetadaten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Reflexion verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Erstellen eines benutzerdefinierten Metadaten-Viewers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Dynamisches Laden von Baugruppen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
Nachdenken über gemeinsame Versammlungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Late Binding verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
viii nINHALT
Attributierte Programmierung verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Erstellen benutzerdefinierter Attribute. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
Attribute auf Baugruppenebene (und Modulebene). . . . . . . . . . . . . . . . . . . . . . . . . . 549
Nachdenken über Attribute mithilfe der frühen Bindung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
Nachdenken über Attribute mithilfe der späten Bindung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
Reflexion, späte Bindung und benutzerdefinierte Attribute ins rechte Licht rücken. . . . . . 553
Erstellen einer erweiterbaren Anwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
nKAPITEL 17 Prozesse, AppDomains und Objektkontexte . . . . . . . . . . . . . . . . . . . 561
Überprüfung traditioneller Win32-Prozesse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
Interaktion mit Prozessen unter der .NET-Plattform. . . . . . . . . . . . . . . . . . . . . . 563
Grundlegendes zu .NET-Anwendungsdomänen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Objektkontextgrenzen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Zusammenfassen von Prozessen, AppDomains und Kontext. . . . . . . . . . . . . . . . . . . . . . 581
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
nKAPITEL 18 Erstellen von Multithread-Anwendungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Die Prozess-/AppDomain-/Kontext-/Thread-Beziehung. . . . . . . . . . . . . . . . . . . . 583
Ein kurzer Überblick über den .NET-Delegierten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
Die asynchrone Natur von Delegierten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Asynchrones Aufrufen einer Methode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
Der System.Threading-Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Die System.Threading.Thread-Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Sekundäre Threads programmgesteuert erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . 597
Das Problem der Parallelität. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
Programmierung mit Timer-Rückrufen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Den CLR-ThreadPool verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Die Rolle der BackgroundWorker-Komponente. . . . . . . . . . . . . . . . . . . . . . . . . . 612
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
nKAPITEL 19 CIL und die Rolle dynamischer Baugruppen verstehen. . . . . . . . 617
Nachdenken über die Natur der CIL-Programmierung. . . . . . . . . . . . . . . . . . . . . . . . . . . 617
Untersuchen von CIL-Anweisungen, Attributen und Opcodes. . . . . . . . . . . . . . . . . . . . . . . 618
Pushing und Popping: Die stapelbasierte Natur von CIL. . . . . . . . . . . . . . . . . . . . 620
Round-Trip-Engineering verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
CIL-Anweisungen und -Attribute verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
.NET-Basisklassenbibliothek, C#- und CIL-Datentypzuordnungen. . . . . . . . . . . . . . . . 635
Definieren von Typmitgliedern in CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
Untersuchen von CIL-Opcodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Erstellen einer .NET-Assembly mit CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
Dynamische Baugruppen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
nINHALT ix
Teil 5 nnn Einführung in die .NET-Basisklassenbibliotheken
nKAPITEL 20 Datei-E/A und isolierter Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Erkundung des System.IO-Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Die Typen Verzeichnis (Info) und Datei (Info). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Arbeiten mit dem DirectoryInfo-Typ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
Arbeiten mit dem Verzeichnistyp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
Arbeiten mit dem DriveInfo-Klassentyp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
Arbeiten mit der FileInfo-Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Arbeiten mit dem Dateityp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
Die Abstract Stream-Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
Arbeiten mit StreamWriters und StreamReaders . . . . . . . . . . . . . . . . . . . . . . . . 677
Arbeiten mit StringWritern und StringReadern. . . . . . . . . . . . . . . . . . . . . . . . . . 680
Arbeiten mit BinaryWriters und BinaryReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 682
Programmgesteuertes „Beobachten“ von Dateien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Asynchrone Datei-E/A durchführen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
Die Rolle der isolierten Speicherung verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
Eine Einführung in die Codezugriffssicherheit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688
Ein Überblick über isolierte Speicherung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
Abrufen eines Stores mithilfe von InsulatedStorageFile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
Isolierter Speicher in Aktion: ClickOnce-Bereitstellung. . . . . . . . . . . . . . . . . . . . . . . . 707
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
nKAPITEL 21 Einführung in die Objektserialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Grundlegendes zur Objektserialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Konfigurieren von Objekten für die Serialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
Auswählen eines Serialisierungsformatierers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Serialisieren von Objekten mit dem BinaryFormatter . . . . . . . . . . . . . . . . . . . . . . . . . . . 717
Serialisieren von Objekten mit dem SoapFormatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
Serialisieren von Objekten mit dem XmlSerializer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720
Serialisierung von Objektsammlungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
Anpassen des Serialisierungsprozesses. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
nKAPITEL 22 ADO.NET Teil I: Die verbundene Schicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Eine High-Level-Definition von ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Grundlegendes zu ADO.NET-Datenanbietern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733
Zusätzliche ADO.NET-Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
Die Typen des System.Data-Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
Abstrahieren von Datenanbietern mithilfe von Schnittstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
Erstellen der AutoLot-Datenbank. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
Das ADO.NET-Datenanbieter-Factory-Modell. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749
Die verbundene Schicht von ADO.NET verstehen. . . . . . . . . . . . . . . . . . . . . . . . . 755
Arbeiten mit Datenlesern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760
Aufbau einer wiederverwendbaren Datenzugriffsbibliothek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763
x nINHALT
Erstellen eines Konsolen-UI-basierten Frontends. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
Asynchroner Datenzugriff mit SqlCommand . . . . . . . . . . . . . . . . . . . . . . . . . 775
Datenbanktransaktionen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
nKAPITEL 23 ADO.NET Teil II: Die getrennte Schicht . . . . . . . . . . . . . . . . . . . . . . . . 783
Die getrennte Schicht von ADO.NET verstehen. . . . . . . . . . . . . . . . . . . . . . 783
Die Rolle des DataSet verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
Arbeiten mit DataColumns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
Arbeiten mit DataRows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
Arbeiten mit DataTables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793
Binden von DataTable-Objekten an Benutzeroberflächen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 798
Füllen von DataSet/DataTable-Objekten mithilfe von Datenadaptern. . . . . . . . . . . . . . . . . . . 808
Erneuter Besuch von AutoLotDAL.dll. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811
Navigieren in mehrtabellenförmigen DataSet-Objekten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
Die Datenzugriffstools von Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . 820
Entkopplung von automatisch generiertem Code von der UI-Ebene. . . . . . . . . . . . . . . . . . . . . . . 831
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
nKAPITEL 24 Programmierung mit den LINQ-APIs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Die Rolle von LINQ to ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Programmieren mit LINQ to DataSet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Programmieren mit LINQ to SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843
Entitätsklassen mit SqlMetal.exe generieren. . . . . . . . . . . . . . . . . . . . . . . . . . . 848
Erstellen von Entitätsklassen mit Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . 854
Bearbeiten von XML-Dokumenten mit LINQ to XML. . . . . . . . . . . . . . . . . . . . . . . . 857
Navigieren in einem In-Memory-Dokument. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865
nKAPITEL 25 Einführung in Windows Communication Foundation. . . . . . . . . . . . . . . 867
Ein Potpourri verteilter Computing-APIs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867
Die Rolle der WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
Untersuchung der WCF-Kernassemblys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876
Die Visual Studio WCF-Projektvorlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 877
Die grundlegende Zusammensetzung einer WCF-Anwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . 879
Das ABC der WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880
Erstellen eines WCF-Dienstes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885
Hosten des WCF-Dienstes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888
Erstellen der WCF-Clientanwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896
Verwenden der Projektvorlage der WCF-Dienstbibliothek. . . . . . . . . . . . . . . . . . . . . . . . . 900
Hosten des WCF-Dienstes als Windows-Dienst. . . . . . . . . . . . . . . . . . . . . . . . . 903
Einen Dienst asynchron aufrufen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
Entwerfen von WCF-Datenverträgen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 915
nINHALT xi
nKAPITEL 26 Einführung in Windows Workflow Foundation . . . . . . . . . . . . . . . . . . . . . 917
Definieren eines Geschäftsprozesses. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
Die Bausteine von WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
WF-Assemblys, Namespaces und Projekte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
Erstellen einer einfachen Workflow-fähigen Anwendung. . . . . . . . . . . . . . . . . . . . . . . . . 926
Untersuchen des WF Engine-Hostingcodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 930
Aufrufen von Webdiensten innerhalb von Workflows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934
Erstellen einer wiederverwendbaren WF-Codebibliothek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945
Ein kurzes Wort zu benutzerdefinierten Aktivitäten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 951
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952
Teil 6 nnn Desktop-Benutzeroberflächen
nKAPITEL 27 Programmieren mit Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
Die Windows Forms-Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
Erstellen einer einfachen Windows Forms-Anwendung (IDE-frei). . . . . . . . . . . . . . . . . . 956
Die Visual Studio Windows Forms-Projektvorlage. . . . . . . . . . . . . . . . . . . . . . 961
Die Anatomie einer Form. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 968
Auf Mausaktivität reagieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975
Auf Tastaturaktivität reagieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977
Entwerfen von Dialogfeldern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 978
Grafische Daten mit GDI+ rendern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 985
Erstellen einer vollständigen Windows Forms-Anwendung. . . . . . . . . . . . . . . . . . . . . . . . 990
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 997
nKAPITEL 28 Einführung in Windows Presentation Foundation und XAML. . . . . . . 999
Die Motivation hinter WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 999
Die verschiedenen Varianten von WPF-Anwendungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002
Untersuchung der WPF-Assemblys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004
Erstellen einer (XAML-freien) WPF-Anwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1011
Zusätzliche Details zum Anwendungstyp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015
Zusätzliche Details zum Fenstertyp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017
Erstellen einer (XAML-zentrierten) WPF-Anwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1021
Markup in eine .NET-Assembly umwandeln. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025
Trennung von Anliegen mithilfe von Code-Behind-Dateien. . . . . . . . . . . . . . . . . . . . . . . 1029
Die Syntax von XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
Erstellen von WPF-Anwendungen mit Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . 1044
XAML zur Laufzeit verarbeiten: SimpleXamlPad.exe . . . . . . . . . . . . . . . . . . . . . . 1048
Die Rolle von Microsoft Expression Blend. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
xii nINHALT
nKAPITEL 29 Programmieren mit WPF-Steuerelementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
Ein Überblick über die WPF-Kontrollbibliothek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
Deklarieren von Steuerelementen in XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1058
Die Rolle von Abhängigkeitseigenschaften verstehen. . . . . . . . . . . . . . . . . . . . . . 1060
Routing-Ereignisse verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1064
Arbeiten mit Schaltflächentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1068
Arbeiten mit CheckBoxes und RadioButtons. . . . . . . . . . . . . . . . . . . . . . . . . . . 1072
Arbeiten mit den ListBox- und ComboBox-Typen. . . . . . . . . . . . . . . . . . . . . . . . 1075
Arbeiten mit Textbereichen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081
Steuern des Inhaltslayouts mithilfe von Bedienfeldern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1083
Erstellen eines Fensterrahmens mit verschachtelten Paneelen. . . . . . . . . . . . . . . . . . . . . . . 1093
WPF-Steuerbefehle verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099
Das WPF-Datenbindungsmodell verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . 1102
Datenkonvertierung mit IValueConverter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1106
Bindung an benutzerdefinierte Objekte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1108
Bindung von UI-Elementen an XML-Dokumente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1116
nKAPITEL 30 WPF 2D-Grafik-Rendering, Ressourcen und Designs . . . . . . . . . 1117
Die Philosophie der grafischen Rendering-Dienste von WPF. . . . . . . . . . . . . . . . . . . . 1117
Erkundung der von der Form abgeleiteten Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1124
Arbeiten mit WPF-Pinseln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1127
Arbeiten mit WPF-Stiften. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1130
Erkundung der von Zeichnungen abgeleiteten Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1130
Die Rolle von UI-Transformationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1135
Grundlegendes zu den Animationsdiensten von WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1136
Das WPF-Ressourcensystem verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145
Stile für WPF-Steuerelemente definieren und anwenden. . . . . . . . . . . . . . . . . . . . . . . . . 1147
Ändern der Benutzeroberfläche eines Steuerelements mithilfe von Vorlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1160
Teil 7 nnn Webanwendungen mit ASP.NET erstellen
nKAPITEL 31 Erstellen von ASP.NET-Webseiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163
Die Rolle von HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163
Webanwendungen und Webserver verstehen. . . . . . . . . . . . . . . . . . . . . . 1164
Die Rolle von HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1167
Die Rolle des clientseitigen Scriptings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172
Senden der Formulardaten (GET und POST). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174
Erstellen einer klassischen ASP-Seite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175
Probleme mit klassischem ASP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177
Die ASP.NET-Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1178
Das ASP.NET-Webseitencodemodell. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1179
Details einer ASP.NET-Website-Verzeichnisstruktur. . . . . . . . . . . . . . . . . . . . . . 1190
Der ASP.NET-Seitenkompilierungszyklus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1192
nINHALT xiii
Die Vererbungskette des Seitentyps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1194
Interaktion mit der eingehenden HTTP-Anfrage. . . . . . . . . . . . . . . . . . . . . . . . . . . 1195
Interaktion mit der ausgehenden HTTP-Antwort. . . . . . . . . . . . . . . . . . . . . . . . . . 1198
Der Lebenszyklus einer ASP.NET-Webseite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1200
Die Rolle der Web.config-Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1203
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1206
nKAPITEL 32 ASP.NET-Websteuerelemente, Designs und Masterseiten . . . . . . . . . . . . 1207
Die Natur von Webkontrollen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1207
Der System.Web.UI.Control-Typ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1209
Der System.Web.UI.WebControls.WebControl-Typ. . . . . . . . . . . . . . . . . . . . . . 1213
Hauptkategorien von ASP.NET-Websteuerelementen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213
Erstellen einer funktionsreichen ASP.NET-Website. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215
Die Rolle der Validierungskontrollen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1231
Arbeiten mit Themen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1237
Positionierungssteuerelemente mithilfe von HTML-Tabellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244
nKAPITEL 33 ASP.NET-Statusverwaltungstechniken. . . . . . . . . . . . . . . . . . . . . . . 1245
Die Frage des Staates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1245
ASP.NET-Statusverwaltungstechniken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1247
Die Rolle des ASP.NET View State verstehen. . . . . . . . . . . . . . . . . . . . . . . . . 1248
Die Rolle der Global.asax-Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1251
Die Unterscheidung zwischen Anwendung und Sitzung verstehen. . . . . . . . . . . . . . . . . . . . . . 1254
Arbeiten mit dem Anwendungscache. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259
Sitzungsdaten pflegen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1263
Cookies verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267
Die Rolle des -Elements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1269
Grundlegendes zur ASP.NET-Profil-API. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1272
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1279
Teil 8 nnn Anhänge
nANHANG A COM- und .NET-Interoperabilität. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283
Der Umfang der .NET-Interoperabilität. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283
Ein einfaches Beispiel für .NET zu COM Interop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1284
Untersuchen einer .NET-Interop-Assembly. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1287
Den Runtime Callable Wrapper verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . 1289
Die Rolle von COM IDL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1292
Verwenden einer Typbibliothek zum Erstellen einer Interop-Assembly. . . . . . . . . . . . . . . . . . . . . . 1296
Aufbau eines ausgefeilteren COM-Servers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1299
Untersuchen der Interop-Assembly. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1301
Grundlegendes zur COM-zu-.NET-Interoperabilität. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1305
Die Rolle des CCW. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1306
Die Rolle der .NET-Klassenschnittstelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1307
xiv nINHALT
Erstellen Ihrer .NET-Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1308
Generieren der Typbibliothek und Registrieren der .NET-Typen. . . . . . . . . . . . . . 1310
Untersuchen der exportierten Typinformationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1311
Erstellen eines Visual Basic 6.0-Testclients. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1313
nANHANG B Plattformunabhängige .NET-Entwicklung mit Mono . . . . . . . . . . . 1315
Die Plattformunabhängigkeit von .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1315
Mono beziehen und installieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1318
Die Mono-Entwicklungstools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1321
Erstellen von .NET-Anwendungen mit Mono. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1323
Vorschläge für weitere Studien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1330
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1331
nINDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1333
Expandieren
