Visual C# 2012 - Das umfassende Handbuch
von: Andreas Kühnel
Galileo Press, 2012
ISBN: 9783836219976
Sprache: Deutsch
1403 Seiten, Download: 20420 KB
Format: PDF, auch als Online-Lesen
Inhalt | 6 | ||
Vorwort zur 6. Auflage | 32 | ||
Kapitel 1 | 34 | ||
Allgemeine Einführung in .NET | 34 | ||
1.1 Warum .NET? | 34 | ||
1.1.1 Ein paar Worte zu diesem Buch | 36 | ||
1.1.2 Die Beispielprogramme | 38 | ||
1.2 .NET unter die Lupe genommen | 39 | ||
1.2.1 Das Entwicklerdilemma | 39 | ||
1.2.2 .NET - Ein paar allgemeine Eigenschaften | 40 | ||
1.2.3 Das Sprachenkonzept | 41 | ||
1.2.4 Die »Common Language Specification« (CLS) | 43 | ||
1.2.5 Das »Common Type System« (CTS) | 44 | ||
1.2.6 Das .NET Framework | 45 | ||
1.2.7 Die »Common Language Runtime« (CLR) | 46 | ||
1.2.8 Die .NET-Klassenbibliothek | 46 | ||
1.2.9 Das Konzept der Namespaces | 48 | ||
1.3 Assemblys | 49 | ||
1.3.1 Die Metadaten | 50 | ||
1.3.2 Das Manifest | 51 | ||
1.4 Die Entwicklungsumgebung | 51 | ||
1.4.1 Editionen von Visual Studio 2012 | 51 | ||
1.4.2 Hard- und Softwareanforderungen | 52 | ||
1.4.3 Die Installation | 52 | ||
1.4.4 Die Entwicklungsumgebung von Visual Studio 2012 | 53 | ||
Kapitel 2 | 58 | ||
Grundlagen der Sprache C# | 58 | ||
2.1 Konsolenanwendungen | 58 | ||
2.1.1 Allgemeine Anmerkungen | 58 | ||
2.1.2 Ein erstes Konsolenprogramm | 58 | ||
2.2 Grundlagen der C#-Syntax | 61 | ||
2.2.1 Kennzeichnen, dass eine Anweisung abgeschlossen ist | 61 | ||
2.2.2 Anweisungs- und Gliederungsblöcke | 62 | ||
2.2.3 Kommentare | 63 | ||
2.2.4 Die Groß- und Kleinschreibung | 64 | ||
2.2.5 Die Struktur einer Konsolenanwendung | 65 | ||
2.3 Variablen und Datentypen | 67 | ||
2.3.1 Variablendeklaration | 67 | ||
2.3.2 Der Variablenbezeichner | 68 | ||
2.3.3 Der Zugriff auf eine Variable | 69 | ||
2.3.4 Ein- und Ausgabemethoden der Klasse »Console« | 69 | ||
2.3.5 Die einfachen Datentypen | 75 | ||
2.3.6 Typkonvertierung | 81 | ||
2.4 Operatoren | 88 | ||
2.4.1 Arithmetische Operatoren | 89 | ||
2.4.2 Vergleichsoperatoren | 92 | ||
2.4.3 Logische Operatoren | 92 | ||
2.4.4 Bitweise Operatoren | 96 | ||
2.4.5 Zuweisungsoperatoren | 99 | ||
2.4.6 Stringverkettung | 99 | ||
2.4.7 Sonstige Operatoren | 100 | ||
2.4.8 Operator-Vorrangregeln | 100 | ||
2.5 Datenfelder (Arrays) | 101 | ||
2.5.1 Die Deklaration und Initialisierung eines Arrays | 101 | ||
2.5.2 Der Zugriff auf die Array-Elemente | 103 | ||
2.5.3 Mehrdimensionale Arrays | 104 | ||
2.5.4 Festlegen der Array-Größe zur Laufzeit | 105 | ||
2.5.5 Bestimmung der Array-Obergrenze | 106 | ||
2.5.6 Die Gesamtanzahl der Array-Elemente | 107 | ||
2.5.7 Verzweigte Arrays | 107 | ||
2.6 Kontrollstrukturen | 109 | ||
2.6.1 Die »if«-Anweisung | 109 | ||
2.6.2 Das »switch«-Statement | 114 | ||
2.7 Programmschleifen | 118 | ||
2.7.1 Die »for«-Schleife | 119 | ||
2.7.2 Die »foreach«-Schleife | 129 | ||
2.7.3 Die »do«- und die »while«-Schleife | 130 | ||
Kapitel 3 | 134 | ||
Das Klassendesign | 134 | ||
3.1 Einführung in die Objektorientierung | 134 | ||
3.2 Die Klassendefinition | 137 | ||
3.2.1 Klassen im Visual Studio anlegen | 137 | ||
3.2.2 Das Projekt »GeometricObjectsSolution« | 137 | ||
3.2.3 Die Deklaration von Objektvariablen | 140 | ||
3.2.4 Zugriffsmodifizierer einer Klasse | 141 | ||
3.2.5 Splitten einer Klassendefinition mit »partial« | 141 | ||
3.2.6 Arbeiten mit Objektreferenzen | 142 | ||
3.3 Referenz- und Wertetypen | 144 | ||
3.3.1 Werte- und Referenztypen nutzen | 145 | ||
3.4 Die Eigenschaften eines Objekts | 146 | ||
3.4.1 Öffentliche Felder | 146 | ||
3.4.2 Datenkapselung mit Eigenschaftsmethoden sicherstellen | 148 | ||
3.4.3 Die Ergänzung der Klasse »Circle« | 150 | ||
3.4.4 Lese- und schreibgeschützte Eigenschaften | 150 | ||
3.4.5 Sichtbarkeit der Accessoren »get« und »set« | 151 | ||
3.4.6 Unterstützung von Visual Studio 2012 | 152 | ||
3.4.7 Automatisch implementierte Eigenschaften | 153 | ||
3.5 Methoden eines Objekts | 154 | ||
3.5.1 Methoden mit Rückgabewert | 154 | ||
3.5.2 Methoden ohne Rückgabewert | 158 | ||
3.5.3 Methoden mit Parameterliste | 158 | ||
3.5.4 Methodenüberladung | 160 | ||
3.5.5 Variablen innerhalb einer Methode (lokale Variablen) | 163 | ||
3.5.6 Referenz- und Wertparameter | 164 | ||
3.5.7 Besondere Aspekte einer Parameterliste | 169 | ||
3.5.8 Zugriff auf private Daten | 174 | ||
3.5.9 Die Trennung von Daten und Code | 175 | ||
3.5.10 Namenskonflikte mit »this« lösen | 176 | ||
3.5.11 Methode oder Eigenschaft? | 177 | ||
3.5.12 Umbenennen von Methoden und Eigenschaften | 178 | ||
3.6 Konstruktoren | 179 | ||
3.6.1 Konstruktoren bereitstellen | 180 | ||
3.6.2 Die Konstruktoraufrufe | 181 | ||
3.6.3 Definition von Konstruktoren | 181 | ||
3.6.4 »public«- und »internal«-Konstruktoren | 182 | ||
3.6.5 »private«-Konstruktoren | 182 | ||
3.6.6 Konstruktorenaufrufe umleiten | 183 | ||
3.6.7 Vereinfachte Objektinitialisierung | 184 | ||
3.7 Der Destruktor | 185 | ||
3.8 Konstanten in einer Klasse | 186 | ||
3.8.1 Konstanten mit dem Schlüsselwort »const« | 186 | ||
3.8.2 Schreibgeschützte Felder mit »readonly« | 187 | ||
3.9 Statische Klassenkomponenten | 187 | ||
3.9.1 Statische Eigenschaften | 187 | ||
3.9.2 Statische Methoden | 190 | ||
3.9.3 Statische Klasseninitialisierer | 191 | ||
3.9.4 Statische Klassen | 192 | ||
3.9.5 Statische Klasse oder Singleton-Pattern? | 193 | ||
3.10 Namensräume (Namespaces) | 194 | ||
3.10.1 Zugriff auf Namespaces | 195 | ||
3.10.2 Die »using«-Direktive | 197 | ||
3.10.3 Globaler Namespace | 198 | ||
3.10.4 Vermeiden von Mehrdeutigkeiten | 198 | ||
3.10.5 Namespaces festlegen | 199 | ||
3.10.6 Der »::«-Operator | 201 | ||
3.10.7 Unterstützung von Visual Studio 2012 bei den Namespaces | 202 | ||
3.11 Stand der Klasse »Circle« | 204 | ||
Kapitel 4 | 206 | ||
Vererbung, Polymorphie und Interfaces | 206 | ||
4.1 Die Vererbung | 206 | ||
4.1.1 Basisklassen und abgeleitete Klassen | 206 | ||
4.1.2 Die Ableitung einer Klasse | 207 | ||
4.1.3 Klassen, die nicht abgeleitet werden können | 209 | ||
4.1.4 Konstruktoren in abgeleiteten Klassen | 209 | ||
4.1.5 Der Zugriffsmodifizierer »protected« | 210 | ||
4.1.6 Die Konstruktorverkettung in der Vererbung | 211 | ||
4.2 Der Problemfall geerbter Methoden | 215 | ||
4.2.1 Geerbte Methoden mit »new« verdecken | 217 | ||
4.2.2 Abstrakte Methoden | 218 | ||
4.2.3 Virtuelle Methoden | 220 | ||
4.3 Typumwandlung und Typuntersuchung von Objektvariablen | 221 | ||
4.3.1 Die implizite Typumwandlung von Objektreferenzen | 221 | ||
4.3.2 Die explizite Typumwandlung von Objektreferenzen | 223 | ||
4.3.3 Typuntersuchung mit dem »is«-Operator | 224 | ||
4.3.4 Typumwandlung mit dem »as«-Operator | 225 | ||
4.4 Polymorphie | 225 | ||
4.4.1 Die »klassische« Methodenimplementierung | 226 | ||
4.4.2 Abstrakte Methoden | 227 | ||
4.4.3 Virtuelle Methoden | 228 | ||
4.5 Weitere Gesichtspunkte der Vererbung | 231 | ||
4.5.1 Versiegelte Methoden | 231 | ||
4.5.2 Überladen einer Basisklassenmethode | 232 | ||
4.5.3 Statische Member und Vererbung | 233 | ||
4.5.4 Geerbte Methoden ausblenden? | 233 | ||
4.6 Das Projekt »GeometricObjectsSolution« ergänzen | 234 | ||
4.6.1 Die Klasse »GeometricObject« | 234 | ||
4.7 Eingebettete Klassen (Nested Classes) | 238 | ||
4.8 Interfaces (Schnittstellen) | 238 | ||
4.8.1 Einführung in die Schnittstellen | 238 | ||
4.8.2 Die Schnittstellendefinition | 239 | ||
4.8.3 Die Schnittstellenimplementierung | 240 | ||
4.8.4 Die Interpretation der Schnittstellen | 245 | ||
4.8.5 Änderungen am Projekt »GeometricObjects« | 250 | ||
4.9 Das Zerstören von Objekten - der »Garbage Collector« | 252 | ||
4.9.1 Die Arbeitsweise des Garbage Collectors | 252 | ||
4.9.2 Expliziter Aufruf des Garbage Collectors | 253 | ||
4.9.3 Der Destruktor | 254 | ||
4.9.4 Die »IDisposable«-Schnittstelle | 255 | ||
4.9.5 Die Ergänzungen in den Klassen »Circle« und »Rectangle« | 258 | ||
Kapitel 5 | 260 | ||
Delegates und Ereignisse | 260 | ||
5.1 Delegates | 260 | ||
5.1.1 Einführung in das Prinzip der Delegates | 260 | ||
5.1.2 Verwendung von Delegates | 264 | ||
5.1.3 Vereinfachter Delegatenaufruf | 264 | ||
5.1.4 Multicast-Delegates | 265 | ||
5.1.5 Anonyme Methoden | 267 | ||
5.1.6 Kovarianz und Kontravarianz mit Delegaten | 269 | ||
5.2 Ereignisse eines Objekts | 271 | ||
5.2.1 Ereignisse bereitstellen | 272 | ||
5.2.2 Die Reaktion auf ein ausgelöstes Ereignis | 274 | ||
5.2.3 Allgemeine Betrachtungen der Ereignishandler-Registrierung | 276 | ||
5.2.4 Wenn der Ereignisempfänger ein Ereignis nicht behandelt | 277 | ||
5.2.5 Ereignisse mit Übergabeparameter | 278 | ||
5.2.6 Ereignisse in der Vererbung | 282 | ||
5.2.7 Hinter die Kulissen des Schlüsselworts »event« geblickt | 283 | ||
5.2.8 Die Schnittstelle »INotifyPropertyChanged« | 285 | ||
5.3 Änderungen im Projekt »GeometricObjects« | 286 | ||
5.3.1 Überarbeitung des Events »InvalidMeasure« | 286 | ||
5.3.2 Weitere Ereignisse | 287 | ||
Kapitel 6 | 290 | ||
Strukturen und Enumerationen | 290 | ||
6.1 Strukturen - eine Sonderform der Klassen | 290 | ||
6.1.1 Die Definition einer Struktur | 290 | ||
6.1.2 Initialisieren einer Strukturvariablen | 291 | ||
6.1.3 Konstruktoren in Strukturen | 292 | ||
6.1.4 Änderung im Projekt »GeometricObjects« | 293 | ||
6.2 Enumerationen (Aufzählungen) | 296 | ||
6.2.1 Wertzuweisung an enum-Mitglieder | 297 | ||
6.2.2 Alle Mitglieder einer Aufzählung durchlaufen | 298 | ||
6.3 Boxing und Unboxing | 299 | ||
Kapitel 7 | 300 | ||
Fehlerbehandlung und Debugging | 300 | ||
7.1 Laufzeitfehler behandeln | 300 | ||
7.1.1 Laufzeitfehler erkennen | 301 | ||
7.1.2 Die »try...catch«-Anweisung | 303 | ||
7.1.3 Behandlung mehrerer Exceptions | 305 | ||
7.1.4 Die Reihenfolge der »catch«-Zweige | 307 | ||
7.1.5 Ausnahmen in einer Methodenaufrufkette | 308 | ||
7.1.6 Ausnahmen werfen oder weiterleiten | 308 | ||
7.1.7 Die »finally«-Anweisung | 309 | ||
7.1.8 Die Klasse »Exception« | 310 | ||
7.1.9 Benutzerdefinierte Ausnahmen | 315 | ||
7.2 Debuggen mit Programmcode | 320 | ||
7.2.1 Einführung | 320 | ||
7.2.2 Die Klasse »Debug« | 321 | ||
7.2.3 Die Klasse »Trace« | 325 | ||
7.2.4 Bedingte Kompilierung | 325 | ||
7.3 Fehlersuche mit Visual Studio 2012 | 328 | ||
7.3.1 Debuggen im Haltemodus | 328 | ||
7.3.2 Das »Direktfenster« | 331 | ||
7.3.3 Weitere Alternativen, um Variableninhalte zu prüfen | 332 | ||
Kapitel 8 | 334 | ||
Auflistungsklassen (Collections) | 334 | ||
8.1 Grundlagen | 334 | ||
8.2 Collections im Namespace »System.Collections« | 334 | ||
8.2.1 Die elementaren Schnittstellen der Auflistungsklassen | 336 | ||
8.3 Die Klasse »ArrayList« | 338 | ||
8.3.1 Einträge hinzufügen | 338 | ||
8.3.2 Datenaustausch zwischen einem Array und einer »ArrayList« | 341 | ||
8.3.3 Die Elemente einer »ArrayList« sortieren | 342 | ||
8.3.4 Sortieren von Arrays mit »ArrayList.Adapter« | 347 | ||
8.4 Die Klasse »Hashtable« | 349 | ||
8.4.1 Methoden und Eigenschaften der Schnittstelle »IDictionary« | 349 | ||
8.4.2 Beispielprogramm zur Klasse »Hashtable« | 350 | ||
8.5 Die Klassen »Queue« und »Stack« | 354 | ||
8.5.1 Die Klasse »Stack« | 355 | ||
8.5.2 Die Klasse »Queue« | 356 | ||
8.6 Eigene Auflistungen mit »yield« durchlaufen | 357 | ||
Kapitel 9 | 360 | ||
Generics - Generische Datentypen | 360 | ||
9.1 Problembeschreibung | 360 | ||
9.2 Bereitstellen einer generischen Klasse | 361 | ||
9.2.1 Mehrere generische Typparameter | 363 | ||
9.2.2 Vorteile der Generics | 364 | ||
9.3 Bedingungen (Constraints) festlegen | 364 | ||
9.3.1 Constraints mit der »where«-Klausel | 364 | ||
9.3.2 Typparameter auf Klassen oder Strukturen beschränken | 366 | ||
9.3.3 Mehrere Constraints definieren | 366 | ||
9.3.4 Der Konstruktor-Constraint »new()« | 367 | ||
9.3.5 Das Schlüsselwort »default« | 367 | ||
9.4 Generische Methoden | 368 | ||
9.4.1 Methoden und Constraints | 369 | ||
9.5 Generics und Vererbung | 369 | ||
9.5.1 Virtuelle generische Methoden | 370 | ||
9.6 Konvertierung von Generics | 371 | ||
9.7 Generische Delegates | 372 | ||
9.7.1 Generische Delegates und Constraints | 373 | ||
9.7.2 Anpassung des Beispiels »GeometricObjects« | 373 | ||
9.8 Nullable-Typen | 374 | ||
9.8.1 Konvertierungen mit Nullable-Typen | 375 | ||
9.9 Generische Collections | 375 | ||
9.9.1 Die Interfaces der generischen Auflistungsklassen | 376 | ||
9.9.2 Die generische Auflistungsklasse »List |
376 | ||
9.9.3 Vergleiche mit Hilfe des Delegaten »Comparison |
379 | ||
9.10 Kovarianz und Kontravarianz generischer Typen | 380 | ||
9.10.1 Kovarianz mit Interfaces | 380 | ||
9.10.2 Kontravarianz mit Interfaces | 382 | ||
9.10.3 Zusammenfassung | 383 | ||
9.10.4 Generische Delegaten mit varianten Typparametern | 384 | ||
Kapitel 10 | 386 | ||
Weitere C#-Sprachfeatures | 386 | ||
10.1 Implizit typisierte Variablen | 386 | ||
10.2 Anonyme Typen | 387 | ||
10.3 Lambda-Ausdrücke | 388 | ||
10.3.1 Projektion und Prädikat | 390 | ||
10.4 Erweiterungsmethoden | 390 | ||
10.5 Partielle Methoden | 394 | ||
10.5.1 Wo partielle Methoden eingesetzt werden | 395 | ||
10.6 Operatorüberladung | 397 | ||
10.6.1 Einführung | 397 | ||
10.6.2 Die Syntax der Operatorüberladung | 397 | ||
10.6.3 Die Operatorüberladungen im Projekt »GeometricObjectsSolution« | 398 | ||
10.6.4 Die Operatoren »true« und »false« überladen | 403 | ||
10.6.5 Benutzerdefinierte Konvertierungen | 404 | ||
10.7 Indexer | 408 | ||
10.7.1 Überladen von Indexern | 410 | ||
10.7.2 Parameterbehaftete Eigenschaften | 412 | ||
10.8 Attribute | 415 | ||
10.8.1 Das »Flags«-Attribut | 416 | ||
10.8.2 Benutzerdefinierte Attribute | 419 | ||
10.8.3 Attribute auswerten | 423 | ||
10.8.4 Festlegen der Assembly-Eigenschaften in »Assembly-Info.cs« | 425 | ||
10.9 Dynamisches Binden | 427 | ||
10.9.1 Eine kurze Analyse | 428 | ||
10.9.2 Dynamische Objekte | 428 | ||
10.10 Unsicherer (unsafe) Programmcode - Zeigertechnik in C# | 430 | ||
10.10.1 Einführung | 430 | ||
10.10.2 Das Schlüsselwort »unsafe« | 430 | ||
10.10.3 Die Deklaration von Zeigern | 431 | ||
10.10.4 Die »fixed«-Anweisung | 432 | ||
10.10.5 Zeigerarithmetik | 433 | ||
10.10.6 Der Operator »->« | 434 | ||
Kapitel 11 | 436 | ||
LINQ | 436 | ||
11.1 Was ist LINQ? | 436 | ||
11.1.1 Verzögerte Ausführung | 437 | ||
11.1.2 LINQ-Erweiterungsmethoden an einem Beispiel | 438 | ||
11.2 LINQ to Objects | 441 | ||
11.2.1 Musterdaten | 441 | ||
11.2.2 Die allgemeine LINQ-Syntax | 443 | ||
11.3 Die Abfrageoperatoren | 445 | ||
11.3.1 Übersicht der Abfrageoperatoren | 445 | ||
11.3.2 Die »from«-Klausel | 446 | ||
11.3.3 Mit »where« filtern | 447 | ||
11.3.4 Die Projektionsoperatoren | 450 | ||
11.3.5 Die Sortieroperatoren | 451 | ||
11.3.6 Gruppieren mit »GroupBy« | 452 | ||
11.3.7 Verknüpfungen mit »Join« | 454 | ||
11.3.8 Die Set-Operatoren-Familie | 457 | ||
11.3.9 Die Familie der Aggregatoperatoren | 458 | ||
11.3.10 Quantifizierungsoperatoren | 461 | ||
11.3.11 Aufteilungsoperatoren | 462 | ||
11.3.12 Die Elementoperatoren | 464 | ||
11.3.13 Die Konvertierungsoperatoren | 467 | ||
Kapitel 12 | 468 | ||
Arbeiten mit Dateien und Streams | 468 | ||
12.1 Einführung | 468 | ||
12.2 Namespaces der Ein- bzw. Ausgabe | 469 | ||
12.2.1 Das Behandeln von Ausnahmen bei E/A-Operationen | 470 | ||
12.3 Laufwerke, Verzeichnisse und Dateien | 470 | ||
12.3.1 Die Klasse »File« | 470 | ||
12.3.2 Die Klasse »FileInfo« | 476 | ||
12.3.3 Die Klassen »Directory« und »DirectoryInfo« | 479 | ||
12.3.4 Die Klasse »Path« | 483 | ||
12.3.5 Die Klasse »DriveInfo« | 485 | ||
12.4 Die »Stream«-Klassen | 486 | ||
12.4.1 Die abstrakte Klasse »Stream« | 487 | ||
12.4.2 Die von »Stream« abgeleiteten Klassen im Überblick | 489 | ||
12.4.3 Die Klasse »FileStream« | 490 | ||
12.5 Die Klassen »TextReader« und »TextWriter« | 497 | ||
12.5.1 Die Klasse »StreamWriter« | 497 | ||
12.5.2 Die Klasse »StreamReader« | 501 | ||
12.6 Die Klassen »BinaryReader« und »BinaryWriter« | 503 | ||
12.6.1 Komplexe binäre Dateien | 505 | ||
Kapitel 13 | 512 | ||
Binäre Serialisierung | 512 | ||
13.1 Einführung in die Serialisierung | 512 | ||
13.1.1 Serialisierungsverfahren | 513 | ||
13.2 Serialisierung mit »BinaryFormatter« | 514 | ||
13.2.1 Die Deserialisierung | 516 | ||
13.2.2 Serialisierung mehrerer Objekte | 517 | ||
Kapitel 14 | 520 | ||
XML | 520 | ||
14.1 Grundlagen | 520 | ||
14.2 XML-Dokumente | 520 | ||
14.2.1 Wohlgeformte und gültige XML-Dokumente | 521 | ||
14.2.2 Die Regeln eines wohlgeformten XML-Codes | 523 | ||
14.2.3 Kommentare | 526 | ||
14.2.4 Verarbeitungsanweisungen | 526 | ||
14.2.5 Reservierte Zeichen in XML | 527 | ||
14.2.6 CDATA-Abschnitte | 527 | ||
14.2.7 Namensräume (Namespaces) | 528 | ||
14.3 Die Gültigkeit eines XML-Dokuments | 535 | ||
14.3.1 XML Schema Definition (XSD) | 536 | ||
14.3.2 Ein XML-Dokument mit einem XML-Schema verknüpfen | 537 | ||
14.3.3 Die Struktur eines XML-Schemas | 540 | ||
14.4 Die Klasse »XmlReader« | 546 | ||
14.4.1 XML-Dokumente mit einem »XmlReader«-Objekt lesen | 546 | ||
14.4.2 Validieren eines XML-Dokuments | 552 | ||
14.5 Eigenschaften und Methoden der Klasse »XmlReader« | 555 | ||
14.6 Die Klasse »XmlWriter« | 558 | ||
14.6.1 Die Methoden der Klasse »XmlWriter« | 562 | ||
14.7 Navigation durch XML (XPath) | 563 | ||
14.7.1 Die Klasse »XPathNavigator« | 563 | ||
14.7.2 XPath-Ausdrücke | 567 | ||
14.7.3 Der Kontextknoten | 568 | ||
14.7.4 Beispiele mit XPath-Ausdrücken | 570 | ||
14.7.5 Knotenmengen mit der »Select«-Methode | 572 | ||
14.7.6 Auswerten von XPath-Ausdrücken | 576 | ||
14.8 Das Document Object Model (DOM) | 580 | ||
14.8.1 Allgemeines | 580 | ||
14.8.2 Arbeiten mit »XmlDocument« | 582 | ||
14.8.3 »XmlDocument« und »XPathNavigator« | 583 | ||
14.8.4 Die Klasse »XmlNode« (Operationen mit Knoten) | 583 | ||
14.8.5 Manipulieren einer XML-Struktur | 591 | ||
14.8.6 Ändern eines Knotens | 593 | ||
14.8.7 Löschen in einem XML-Dokument | 595 | ||
14.9 Serialisierung mit »XmlSerializer« | 597 | ||
14.9.1 XML-Serialisierung mit Attributen steuern | 599 | ||
14.10 LINQ to XML | 602 | ||
14.10.1 Allgemeines | 602 | ||
14.10.2 Die Klassenhierarchie von LINQ to XML | 602 | ||
14.10.3 Die Klasse »XElement« | 603 | ||
14.10.4 Die Klasse »XDocument« | 606 | ||
14.10.5 Navigation im XML-Dokument | 606 | ||
14.10.6 Änderungen am XML-Dokument vornehmen | 612 | ||
Kapitel 15 | 614 | ||
Multithreading und die Task Parallel Library (TPL) | 614 | ||
15.1 Überblick | 614 | ||
15.2 Multithreading mit der Klasse »Thread« | 615 | ||
15.2.1 Einführung in das Multithreading | 615 | ||
15.2.2 Threadzustände und Prioritäten | 615 | ||
15.2.3 Zusammenspiel mehrerer Threads | 617 | ||
15.2.4 Die Entwicklung einer einfachen Multithreading-Anwendung | 617 | ||
15.2.5 Die Klasse »Thread« | 620 | ||
15.2.6 Threadpools nutzen | 628 | ||
15.2.7 Die Synchronisation von Threads | 630 | ||
15.2.8 Der »Monitor« zur Synchronisation | 632 | ||
15.2.9 Das Attribut »MethodImpl« | 638 | ||
15.2.10 Das Synchronisationsobjekt »Mutex« | 639 | ||
15.2.11 Grundlagen asynchroner Methodenaufrufe | 640 | ||
15.2.12 Asynchroner Methodenaufruf | 641 | ||
15.2.13 Asynchroner Aufruf mit Rückgabewerten | 645 | ||
15.2.14 Eine Klasse mit asynchronen Methodenaufrufen | 648 | ||
15.3 Die TPL (Task Parallel Library) | 651 | ||
15.3.1 Allgemeines zur Parallelisierung mit der TPL | 652 | ||
15.3.2 Die Klasse »Parallel« | 652 | ||
15.3.3 Die Klasse »Task« | 658 | ||
15.4 Asynchrone Programmierung mit »async« und »await« | 662 | ||
Kapitel 16 | 666 | ||
Einige wichtige .NET-Klassen | 666 | ||
16.1 Die Klasse »Object« | 666 | ||
16.1.1 Referenzvergleiche mit »Equals« und »ReferenceEquals« | 667 | ||
16.1.2 »ToString« und »GetType« | 667 | ||
16.1.3 Die Methode »MemberwiseClone« und das Problem des Klonens | 668 | ||
16.2 Die Klasse »String« | 671 | ||
16.2.1 Das Erzeugen eines Strings | 672 | ||
16.2.2 Die Eigenschaften von »String« | 673 | ||
16.2.3 Die Methoden der Klasse »String« | 673 | ||
16.2.4 Zusammenfassung der Klasse »String« | 684 | ||
16.3 Die Klasse »StringBuilder« | 685 | ||
16.3.1 Allgemeines | 685 | ||
16.3.2 Die Kapazität eines »StringBuilder«-Objekts | 686 | ||
16.3.3 Die Konstruktoren der Klasse »StringBuilder« | 687 | ||
16.3.4 Die Eigenschaften der Klasse »StringBuilder« | 687 | ||
16.3.5 Die Methoden der Klasse »StringBuilder« | 688 | ||
16.3.6 Allgemeine Anmerkungen | 690 | ||
16.4 Der Typ »DateTime« | 691 | ||
16.4.1 Die Zeitspanne »Tick« | 691 | ||
16.4.2 Die Konstruktoren von »DateTime« | 692 | ||
16.4.3 Die Eigenschaften von »DateTime« | 693 | ||
16.4.4 Die Methoden der Klasse »DateTime« | 694 | ||
16.5 Die Klasse »TimeSpan« | 695 | ||
16.6 Ausgabeformatierung | 698 | ||
16.6.1 Formatierung mit der Methode »String.Format« | 698 | ||
16.6.2 Formatierung mit der Methode »ToString« | 702 | ||
16.6.3 Benutzerdefinierte Formatierung | 702 | ||
Kapitel 17 | 706 | ||
Projektmanagement und Visual Studio 2012 | 706 | ||
17.1 Der Projekttyp »Klassenbibliothek« | 706 | ||
17.1.1 Mehrere Projekte in einer Projektmappe verwalten | 707 | ||
17.1.2 Die Zugriffsmodifizierer »public« und »internal« | 708 | ||
17.1.3 Friend Assemblys | 708 | ||
17.1.4 Einbinden einer Klassenbibliothek | 709 | ||
17.2 Assemblys | 710 | ||
17.2.1 Ein Überblick über das Konzept der Assemblys | 710 | ||
17.2.2 Allgemeine Beschreibung privater und globaler Assemblys | 711 | ||
17.2.3 Die Struktur einer Assembly | 712 | ||
17.2.4 Globale Assemblys | 717 | ||
17.3 Konfigurationsdateien | 722 | ||
17.3.1 Die verschiedenen Konfigurationsdateien | 722 | ||
17.3.2 Die Struktur einer Anwendungskonfigurationsdatei | 724 | ||
17.3.3 Eine Anwendungskonfigurationsdatei mit Visual Studio 2012 bereitstellen | 727 | ||
17.3.4 Einträge der Anwendungskonfigurationsdatei auswerten | 728 | ||
17.3.5 Editierbare, anwendungsbezogene Einträge mit |
733 | ||
17.4 Versionsumleitung in einer Konfigurationsdatei | 735 | ||
17.4.1 Die Herausgeberrichtliniendatei | 736 | ||
17.5 XML-Dokumentation | 737 | ||
17.5.1 Das Prinzip der XML-Dokumentation | 738 | ||
17.5.2 Die XML-Kommentartags | 740 | ||
17.5.3 Generieren der XML-Dokumentationsdatei | 741 | ||
17.6 Der Klassendesigner (Class Designer) | 743 | ||
17.6.1 Ein typisches Klassendiagramm | 743 | ||
17.6.2 Hinzufügen und Ansicht von Klassendiagrammen | 744 | ||
17.6.3 Die Toolbox des Klassendesigners | 745 | ||
17.6.4 Das Fenster »Klassendetails« | 746 | ||
17.6.5 Klassendiagramme als Bilder exportieren | 748 | ||
17.7 Refactoring | 748 | ||
17.7.1 Methode extrahieren | 749 | ||
17.7.2 Bezeichner umbenennen | 750 | ||
17.7.3 Felder einkapseln | 751 | ||
17.8 Code-Snippets (Codeausschnitte) | 751 | ||
17.8.1 Codeausschnitte einfügen | 752 | ||
17.8.2 Die Anatomie eines Codeausschnitts | 753 | ||
17.9 »ClickOnce«-Verteilung | 754 | ||
17.9.1 Allgemeine Beschreibung | 754 | ||
17.9.2 Erstellen einer ClickOnce-Anwendung | 755 | ||
17.9.3 Die Installation einer ClickOnce-Anwendung | 758 | ||
Kapitel 18 | 760 | ||
Einführung in die WPF und XAML | 760 | ||
18.1 Die Merkmale einer WPF-Anwendung | 760 | ||
18.1.1 Anwendungstypen | 762 | ||
18.1.2 Eine WPF-Anwendung und deren Dateien | 763 | ||
18.1.3 Ein erstes WPF-Beispiel | 766 | ||
18.1.4 Wichtige WPF-Features | 769 | ||
18.1.5 Der logische und der visuelle Elementbaum | 771 | ||
18.2 XAML (Extended Application Markup Language) | 774 | ||
18.2.1 Die Struktur einer XAML-Datei | 775 | ||
18.2.2 Eigenschaften eines XAML-Elements in Attributschreibweise festlegen | 777 | ||
18.2.3 Eigenschaften im Eigenschaftsfenster festlegen | 777 | ||
18.2.4 Die Eigenschaft-Element-Syntax | 778 | ||
18.2.5 Inhaltseigenschaften | 779 | ||
18.2.6 Typkonvertierung | 782 | ||
18.2.7 Markup-Erweiterungen (Markup Extensions) | 783 | ||
18.2.8 XML-Namespaces | 786 | ||
18.2.9 XAML-Spracherweiterungen | 788 | ||
Kapitel 19 | 790 | ||
WPF-Layout-Container | 790 | ||
19.1 Die Container-Steuerelemente | 790 | ||
19.1.1 Gemeinsame Eigenschaften der Layout-Container | 791 | ||
19.1.2 Das »Canvas« | 792 | ||
19.1.3 Das »StackPanel« | 793 | ||
19.1.4 Das »WrapPanel« | 796 | ||
19.1.5 Das »DockPanel« | 797 | ||
19.1.6 Das »Grid«-Steuerelement | 799 | ||
19.1.7 Das »UniformGrid« | 805 | ||
19.2 Verschachteln der Layout-Container | 806 | ||
Kapitel 20 | 810 | ||
Fenster in der WPF | 810 | ||
20.1 Hosts der WPF | 810 | ||
20.2 Fenster vom Typ »Window« | 811 | ||
20.2.1 Mehrere Fenster in einer Anwendung | 813 | ||
20.3 Fenster vom Typ »NavigationWindow« | 815 | ||
20.3.1 Das »Page«-Element | 817 | ||
20.4 Hosts vom Typ »Frame« | 818 | ||
20.5 Navigation zwischen den Seiten | 819 | ||
20.5.1 Navigation mit »HyperLink« | 820 | ||
20.5.2 Der Verlauf der Navigation - das Journal | 821 | ||
20.5.3 Navigation mit »NavigationService« | 823 | ||
20.5.4 Navigation im Internet | 825 | ||
20.5.5 Navigieren mit dem Ereignis »RequestNavigate« des »HyperLink«-Elements | 826 | ||
20.6 Datenübergabe zwischen den Seiten | 826 | ||
20.6.1 Datenübergabe mit der Methode »Navigate« | 827 | ||
20.7 Nachrichtenfenster mit »MessageBox« | 829 | ||
20.7.1 Die Methode »MessageBox.Show« | 830 | ||
Kapitel 21 | 834 | ||
WPF-Steuerelemente | 834 | ||
21.1 Die Hierarchie der WPF-Komponenten | 834 | ||
21.2 Allgemeine Eigenschaften der WPF-Steuerelemente | 836 | ||
21.2.1 Den Außenrand mit der Eigenschaft »Margin« festlegen | 836 | ||
21.2.2 Den Innenrand mit der Eigenschaft »Padding« festlegen | 836 | ||
21.2.3 Die Eigenschaft »Content« | 837 | ||
21.2.4 Die Größe einer Komponente | 839 | ||
21.2.5 Die Ausrichtung einer Komponente | 840 | ||
21.2.6 Die Sichtbarkeit eines Steuerelements | 841 | ||
21.2.7 Die Farbeinstellungen | 842 | ||
21.2.8 Die Schriften | 843 | ||
21.3 Die unterschiedlichen Schaltflächen | 843 | ||
21.3.1 Die Basisklasse »ButtonBase« | 844 | ||
21.3.2 Das Steuerelement »Button« | 844 | ||
21.3.3 Das Steuerelement »ToggleButton« | 845 | ||
21.3.4 Das Steuerelement »RepeatButton« | 846 | ||
21.3.5 Das Steuerelement »Checkbox« | 848 | ||
21.3.6 Das Steuerelement »RadioButton« | 848 | ||
21.4 Einfache Eingabesteuerelemente | 849 | ||
21.4.1 Das Steuerelement »Label« | 849 | ||
21.4.2 Das Steuerelement »TextBox« | 850 | ||
21.4.3 Das Steuerelement »PasswordBox« | 853 | ||
21.4.4 Das Steuerelement »TextBlock« | 854 | ||
21.5 WPF-Listenelemente | 857 | ||
21.5.1 Das Steuerelement »ListBox« | 858 | ||
21.5.2 Die »ComboBox« | 861 | ||
21.5.3 Das Steuerelement »ListView« | 862 | ||
21.5.4 Das Steuerelement »TreeView« | 864 | ||
21.5.5 Das Steuerelement »TabControl« | 870 | ||
21.5.6 Die Menüleiste | 871 | ||
21.5.7 Das Kontextmenü | 874 | ||
21.5.8 Symbolleisten | 876 | ||
21.5.9 Die Statusleiste | 879 | ||
21.6 Weitere Steuerelemente | 880 | ||
21.6.1 Das Steuerelement »ToolTip« | 880 | ||
21.6.2 Die »Progressbar« | 882 | ||
21.6.3 Das Steuerelement »Slider« | 882 | ||
21.6.4 Das »GroupBox«-Steuerelement | 883 | ||
21.6.5 Das Steuerelement »ScrollViewer« | 884 | ||
21.6.6 Das Steuerelement »Expander« | 886 | ||
21.6.7 Das Steuerelement »Border« | 887 | ||
21.6.8 Die »Image«-Komponente | 888 | ||
21.6.9 »Calendar« und »DatePicker« zur Datumsangabe | 890 | ||
21.6.10 Das Steuerelement »InkCanvas« | 891 | ||
21.7 Das »Ribbon«-Steuerelement | 894 | ||
21.7.1 Voraussetzungen für den Zugriff auf das »Ribbon«-Control | 894 | ||
21.7.2 Ein kurzer Überblick | 894 | ||
21.7.3 Der XAML-Code | 895 | ||
21.8 FlowDocuments | 900 | ||
21.8.1 Allgemeine Beschreibung eines FlowDocuments | 900 | ||
21.8.2 Eigenschaften eines »FlowDocuments« | 901 | ||
21.8.3 Die Blöcke eines »FlowDocuments« | 901 | ||
21.8.4 Inline-Elemente | 906 | ||
21.8.5 »FlowDocuments« mit Code erzeugen | 908 | ||
21.8.6 Speichern und Laden eines »FlowDocuments« | 911 | ||
21.9 Das Element »FlowDocumentViewer« | 912 | ||
21.9.1 Das Anzeigeelement »FlowDocumentScrollViewer« | 912 | ||
21.9.2 Das Anzeigeelement »FlowDocumentPageViewer« | 913 | ||
21.9.3 Das Anzeigeelement »FlowDocumentReader« | 913 | ||
21.10 XPS-Dokumente mit »DocumentViewer« | 914 | ||
21.10.1 Allgemeines zum XPS-Format | 914 | ||
21.10.2 Beispielprogramm | 915 | ||
21.11 Das Steuerelement »RichTextBox« | 916 | ||
Kapitel 22 | 922 | ||
Elementbindungen | 922 | ||
22.1 Einführung in die Bindungstechnik | 922 | ||
22.1.1 Ein einfaches Bindungsbeispiel | 922 | ||
22.2 Die Klasse »Binding« | 925 | ||
22.2.1 Die Bindungsrichtung festlegen | 926 | ||
22.2.2 Aktualisierung der Bindung | 929 | ||
22.2.3 Die Ereignisse »SourceUpdated« und »TargetUpdated« | 931 | ||
22.2.4 Beenden einer Bindung | 932 | ||
22.3 Bindungsalternativen | 932 | ||
22.3.1 Die Eigenschaft »Source« | 932 | ||
22.3.2 Anbindung an relative Datenquellen | 933 | ||
22.3.3 Die Bindung an »DataContext« | 935 | ||
Kapitel 23 | 936 | ||
Konzepte von WPF | 936 | ||
23.1 Anwendungsspezifische Ressourcen | 936 | ||
23.2 Anwendungsübergreifende Ressourcen | 938 | ||
23.2.1 Mehrere Ressourcenwörterbücher | 940 | ||
23.2.2 Die Suche nach einer Ressource | 941 | ||
23.3 Logische Ressourcen | 941 | ||
23.3.1 Statische Ressourcen | 942 | ||
23.3.2 Dynamische Ressourcen | 945 | ||
23.3.3 Ressourcen mit C#-Code bearbeiten | 946 | ||
23.3.4 Abrufen von Systemressourcen | 947 | ||
23.4 Styles | 949 | ||
23.4.1 Einfache Styles | 949 | ||
23.4.2 Typisierte Styles | 953 | ||
23.4.3 Erweitern von Styles | 954 | ||
23.4.4 EventSetter | 955 | ||
23.5 Trigger | 957 | ||
23.5.1 Eigenschaftstrigger | 958 | ||
23.5.2 Datentrigger | 961 | ||
23.5.3 Ereignistrigger | 962 | ||
23.6 Templates | 963 | ||
23.6.1 Allgemeines zu »ControlTemplates« | 964 | ||
23.6.2 Definition innerhalb eines Styles | 969 | ||
23.7 Ermitteln des visuellen Elementbaums | 970 | ||
23.7.1 Das Tool »Expression Blend« | 970 | ||
23.7.2 Standard-Template mit Code abfragen | 972 | ||
Kapitel 24 | 976 | ||
Datenbindung | 976 | ||
24.1 Bindung benutzerdefinierter Objekte | 976 | ||
24.1.1 Ein Objekt mit XAML-Code erzeugen und binden | 977 | ||
24.1.2 Ein Objekt mit C#-Code erzeugen und binden | 978 | ||
24.1.3 Aktualisieren benutzerdefinierter Objekte | 980 | ||
24.2 Auflistungen binden | 982 | ||
24.2.1 Allgemeine Gesichtspunkte | 982 | ||
24.2.2 Anbindung an eine »ListBox« | 983 | ||
24.2.3 Änderungen der Collection an die bindenden Elemente weiterleiten | 985 | ||
24.3 Validieren von Bindungen | 988 | ||
24.3.1 Die Validierung im Datenobjekt | 989 | ||
24.3.2 Eine benutzerdefinierte »ValidationRule« | 991 | ||
24.3.3 Validierung mit der Schnittstelle »IDataErrorInfo« | 992 | ||
24.3.4 Fehlerhinweise individuell anzeigen | 994 | ||
24.3.5 Ereignisauslösung bei einem Validierungsfehler | 996 | ||
24.4 Daten konvertieren | 996 | ||
24.4.1 Mehrfachbindungen und Konverterklassen | 1000 | ||
24.5 Datenbindung an ADO.NET- und LINQ-Datenquellen | 1001 | ||
24.5.1 Das Binden an ADO.NET-Objekte | 1002 | ||
24.5.2 Das Binden an LINQ-Ausdrücke | 1003 | ||
Kapitel 25 | 1006 | ||
Weitere Möglichkeiten der Datenbindung | 1006 | ||
25.1 »ItemsControl«-Steuerelemente anpassen | 1006 | ||
25.1.1 Den Style eines »ListBoxItem«-Elements ändern | 1007 | ||
25.1.2 DataTemplates festlegen | 1009 | ||
25.1.3 »DataTemplates« mit Trigger | 1011 | ||
25.2 Alternative Datenbindungen | 1015 | ||
25.2.1 Die Klasse »ObjectDataProvider« | 1015 | ||
25.3 Navigieren, Filtern, Sortieren und Gruppieren | 1017 | ||
25.3.1 Navigieren | 1019 | ||
25.3.2 Sortieren | 1022 | ||
25.3.3 Filtern | 1023 | ||
25.3.4 Gruppieren | 1027 | ||
25.4 Das Steuerelement »DataGrid« | 1031 | ||
25.4.1 Elementare Eigenschaften des »DataGrid« | 1033 | ||
25.4.2 Spalten definieren | 1034 | ||
25.4.3 Details einer Zeile anzeigen | 1040 | ||
Kapitel 26 | 1042 | ||
Dependency Properties | 1042 | ||
26.1 Die Charakteristik von Abhängigkeitseigenschaften | 1042 | ||
26.2 Den Wert einer Abhängigkeitseigenschaft bilden | 1043 | ||
26.3 Definition einer Dependency Property | 1044 | ||
26.3.1 Registrieren einer Abhängigkeitseigenschaft | 1045 | ||
26.3.2 Der Eigenschaftswrapper | 1046 | ||
26.3.3 Die Eigenschaftsmetadaten | 1047 | ||
26.3.4 Freigabe des spezifischen Eigenschaftswertes | 1051 | ||
26.3.5 Vererbung von Abhängigkeitseigenschaften | 1051 | ||
26.4 Validieren einer Abhängigkeitseigenschaft | 1052 | ||
26.4.1 Validieren mit »ValidateValueCallback« | 1052 | ||
26.4.2 Validieren mit »CoerceValueCallback« | 1053 | ||
26.5 Angehängte Eigenschaften (Attached Property) | 1054 | ||
26.5.1 Angehängte Eigenschaften zur Laufzeit ändern | 1056 | ||
Kapitel 27 | 1058 | ||
Ereignisse in der WPF | 1058 | ||
27.1 Ereignishandler bereitstellen | 1058 | ||
27.2 Routing-Strategien | 1059 | ||
27.2.1 Der durchlaufene Elementbaum | 1061 | ||
27.2.2 Beispielanwendung | 1061 | ||
27.2.3 Sonderfall der Mausereignisse | 1063 | ||
27.3 Der Ereignishandler | 1064 | ||
27.3.1 Die Klasse »RoutedEventArgs« | 1064 | ||
27.3.2 Die Quelle des Routing-Prozesses | 1065 | ||
27.3.3 Die Eigenschaft »Handled« | 1066 | ||
27.3.4 Registrieren und Deregistrieren eines Ereignishandlers mit Code | 1067 | ||
27.4 Definition eines Routed Events | 1067 | ||
27.4.1 Ereignisauslösung | 1069 | ||
27.4.2 Das Ereignis als Attached Event verwenden | 1070 | ||
27.4.3 Unterdrückte Ereignisse | 1071 | ||
27.5 Mausereignisse in der WPF | 1072 | ||
27.5.1 Ziehen der Maus | 1072 | ||
27.5.2 Auswerten der Mausklicks | 1073 | ||
27.5.3 Capturing | 1074 | ||
Kapitel 28 | 1078 | ||
WPF-Commands | 1078 | ||
28.1 Allgemeine Beschreibung | 1078 | ||
28.1.1 Ein einführendes Beispiel | 1078 | ||
28.2 Vordefinierte WPF-Commands | 1080 | ||
28.3 Commands verwenden | 1081 | ||
28.3.1 Command-Bindungen einrichten | 1082 | ||
28.3.2 Lokalität der Befehlsbindung | 1084 | ||
28.3.3 Befehlsbindung mit Programmcode | 1084 | ||
28.3.4 Das Befehlsziel mit »CommandTarget« angeben | 1085 | ||
28.3.5 Zusätzliche Daten bereitstellen | 1086 | ||
28.3.6 Befehle mit Maus oder Tastatur aufrufen | 1087 | ||
28.4 Die Anatomie eines »Command«-Objekts | 1088 | ||
28.4.1 Das Interface »ICommand« | 1089 | ||
28.4.2 Die Klassen »RoutedCommand« und »RoutedUICommand« | 1089 | ||
28.4.3 Das Interface »ICommandSource« | 1091 | ||
28.5 Das MVVM-Pattern | 1092 | ||
28.5.1 Ein simples Beispielprogramm | 1094 | ||
Kapitel 29 | 1098 | ||
Benutzerdefinierte Controls | 1098 | ||
29.1 Erstellen eines benutzerdefinierten Steuerelements | 1098 | ||
29.2 Der XAML-Code | 1100 | ||
29.3 Die Programmlogik des Steuerelements | 1101 | ||
29.3.1 Die Eigenschaften | 1101 | ||
29.3.2 Ein Ereignis bereitstellen | 1103 | ||
29.3.3 Das Steuerelement um einen »Command« ergänzen | 1104 | ||
29.4 Testanwendung | 1105 | ||
Kapitel 30 | 1108 | ||
2D-Grafik | 1108 | ||
30.1 Shapes | 1108 | ||
30.1.1 Allgemeine Beschreibung | 1108 | ||
30.1.2 Line-Elemente | 1109 | ||
30.1.3 Ellipse- und Rectangle-Elemente | 1110 | ||
30.1.4 Polygon- und Polyline-Elemente | 1110 | ||
30.1.5 Darstellung der Linien | 1110 | ||
30.2 Path-Elemente | 1112 | ||
30.2.1 GeometryGroup | 1113 | ||
30.2.2 CombinedGeometry | 1114 | ||
30.2.3 PathGeometry | 1115 | ||
30.3 Brush-Objekte | 1116 | ||
30.3.1 SolidColorBrush | 1117 | ||
30.3.2 LinearGradientBrush | 1118 | ||
30.3.3 RadialGradientBrush | 1120 | ||
30.3.4 TileBrush | 1121 | ||
30.3.5 ImageBrush | 1123 | ||
30.3.6 VisualBrush | 1124 | ||
30.3.7 DrawingBrush | 1126 | ||
Kapitel 31 | 1128 | ||
ADO.NET - Verbindungsorientierte Objekte | 1128 | ||
31.1 Allgemeines | 1128 | ||
31.2 Die Datenprovider | 1129 | ||
31.3 Die Verbindung zu einer Datenbank herstellen | 1130 | ||
31.3.1 Das Connection-Objekt | 1130 | ||
31.3.2 Die Verbindungszeichenfolge | 1131 | ||
31.3.3 Die Verbindung mit einer SQL Server-Instanz aufbauen | 1132 | ||
31.3.4 Öffnen und Schließen einer Verbindung | 1135 | ||
31.3.5 Das Verbindungspooling | 1139 | ||
31.3.6 Die Ereignisse eines »Connection«-Objekts | 1143 | ||
31.3.7 Verbindungszeichenfolgen aus einer Konfigurationsdatei abrufen | 1145 | ||
31.3.8 Verbindungen mit dem OleDb-Datenprovider | 1147 | ||
Kapitel 32 | 1150 | ||
ADO.NET - Das Command-Objekt | 1150 | ||
32.1 Die Datenbankabfrage | 1150 | ||
32.2 Das SqlCommand-Objekt | 1150 | ||
32.2.1 Erzeugen eines SqlCommand-Objekts | 1151 | ||
32.2.2 Die Methode »CreateCommand« des Connection-Objekts | 1152 | ||
32.2.3 Ausführen des SqlCommand-Objekts | 1152 | ||
32.2.4 Die Eigenschaft »CommandTimeout« des SqlCommand-Objekts | 1153 | ||
32.3 Aktionsabfragen absetzen | 1153 | ||
32.3.1 Datensätze hinzufügen | 1153 | ||
32.3.2 Datensätze löschen | 1154 | ||
32.3.3 Datensätze ändern | 1155 | ||
32.3.4 Abfragen, die genau ein Ergebnis liefern | 1155 | ||
32.4 Das SqlDataReader-Objekt | 1155 | ||
32.4.1 Datensätze einlesen | 1156 | ||
32.4.2 Schließen des SqlDataReader-Objekts | 1158 | ||
32.4.3 MARS (Multiple Active Resultsets) | 1159 | ||
32.4.4 Batchabfragen mit »NextResult« durchlaufen | 1160 | ||
32.4.5 Das Schema eines SqlDataReader-Objekts untersuchen | 1161 | ||
32.5 Parametrisierte Abfragen | 1163 | ||
32.5.1 Parametrisierte Abfragen mit dem SqlClient-Datenprovider | 1163 | ||
32.5.2 Die Klasse »SqlParameter« | 1166 | ||
32.5.3 Asynchrone Abfragen | 1166 | ||
32.5.4 Gespeicherte Prozeduren (Stored Procedures) | 1170 | ||
Kapitel 33 | 1178 | ||
ADO.NET - Der SqlDataAdapter | 1178 | ||
33.1 Was ist ein DataAdapter? | 1178 | ||
33.2 Die Konstruktoren der Klasse DataAdapter | 1180 | ||
33.3 Arbeiten mit dem SqlDataAdapter | 1180 | ||
33.3.1 Die Eigenschaft »SelectCommand« | 1180 | ||
33.3.2 Den lokalen Datenspeicher mit »Fill« füllen | 1181 | ||
33.3.3 Öffnen und Schließen von Verbindungen | 1182 | ||
33.3.4 Doppelter Aufruf der Fill-Methode | 1183 | ||
33.3.5 Mehrere DataAdapter-Objekte aufrufen | 1183 | ||
33.3.6 Die Spalten- und der Tabellenbezeichner einer DataTable | 1184 | ||
33.3.7 Paging mit der Fill-Methode | 1184 | ||
33.4 Tabellenzuordnung mit der Klasse »TableMappings« | 1185 | ||
33.4.1 Spaltenzuordnungen in einem DataSet | 1187 | ||
33.4.2 Spaltenzuordnungen einer DataTable | 1188 | ||
33.4.3 Die Eigenschaft »MissingMappingAction« des DataAdapters | 1189 | ||
33.5 Das Ereignis »FillError« des SqlDataAdapters | 1189 | ||
Kapitel 34 | 1192 | ||
ADO.NET - Daten im lokalen Speicher | 1192 | ||
34.1 Allgemeines | 1192 | ||
34.2 Verwenden des DataSet-Objekts | 1193 | ||
34.2.1 Ein DataSet-Objekt erzeugen | 1193 | ||
34.2.2 Die Anatomie einer DataTable | 1193 | ||
34.2.3 Der Zugriff auf eine Tabelle im DataSet | 1194 | ||
34.2.4 Der Zugriff auf die Ergebnisliste | 1195 | ||
34.2.5 Dateninformationen in eine XML-Datei schreiben | 1196 | ||
34.3 Gültigkeitsprüfung im DataSet | 1197 | ||
34.3.1 Dem DataSet Schemainformationen übergeben | 1197 | ||
34.3.2 Eigenschaften einer DataColumn, die der Gültigkeitsprüfung dienen | 1199 | ||
34.3.3 Die Constraints-Klassen einer »DataTable« | 1200 | ||
34.3.4 Das Schema mit Programmcode erzeugen | 1201 | ||
34.3.5 Schemainformationen mit SqlDataAdapter abrufen | 1202 | ||
34.4 Änderungen in einer DataTable vornehmen | 1205 | ||
34.4.1 Editieren einer DataRow | 1205 | ||
34.4.2 Löschen einer Datenzeile | 1207 | ||
34.4.3 Eine neue Datenzeile hinzufügen | 1207 | ||
34.4.4 Der Sonderfall: Autoinkrementspalten | 1208 | ||
34.4.5 Was bei einer Änderung einer Datenzeile passiert | 1210 | ||
34.4.6 Manuelles Steuern der Eigenschaft »DataRowState« | 1214 | ||
34.5 Mit mehreren Tabellen arbeiten | 1215 | ||
34.5.1 Der Weg über JOIN-Abfragen | 1215 | ||
34.5.2 Mehrere Tabellen in einem DataSet | 1217 | ||
34.5.3 Eine DataRelation erzeugen | 1217 | ||
34.5.4 DataRelations und Einschränkungen | 1218 | ||
34.5.5 In Beziehung stehende Daten suchen | 1220 | ||
34.5.6 Ergänzung zum Speichern von Schemainformationen in einer XML-Schemadatei | 1222 | ||
34.6 Filtern und suchen in einer DataTable | 1223 | ||
34.6.1 Die Methode »Find« | 1223 | ||
34.6.2 Die Methode »Select« | 1224 | ||
34.7 Objekte vom Typ »DataView« | 1225 | ||
34.7.1 Einen »DataView« erzeugen | 1226 | ||
34.7.2 Auf die Datenzeilen in einem »DataView« zugreifen | 1226 | ||
34.7.3 Die Eigenschaft »Sort« und die Methode »Find« | 1227 | ||
34.7.4 Die Methode »FindRows« | 1227 | ||
34.7.5 Die Eigenschaft »RowFilter« | 1228 | ||
34.7.6 Die Eigenschaft »RowStateFilter« | 1228 | ||
34.7.7 Änderungen an einem »DataView«-Objekt | 1228 | ||
34.7.8 Aus einem »DataView« eine »DataTable« erzeugen | 1230 | ||
Kapitel 35 | 1232 | ||
ADO.NET - Aktualisieren der Datenbank | 1232 | ||
35.1 Aktualisieren mit dem »CommandBuilder« | 1232 | ||
35.1.1 Die von »SqlCommandBuilder« generierten Aktualisierungsstatements | 1234 | ||
35.1.2 Konfliktsteuerung in einer Mehrbenutzerumgebung | 1234 | ||
35.1.3 Die Eigenschaft »ConflictOption« des »SqlCommandBuilders« | 1237 | ||
35.1.4 Die Eigenschaft »SetAllValues« | 1238 | ||
35.2 Manuell gesteuerte Aktualisierung | 1239 | ||
35.2.1 Eigene Aktualisierungslogik | 1240 | ||
35.2.2 Das Beispielprogramm | 1241 | ||
35.3 Konfliktanalyse | 1243 | ||
35.3.1 Den Benutzer über fehlgeschlagene Aktualisierungen informieren | 1244 | ||
35.3.2 Konfliktverursachende Datenzeilen bei der Datenbank abfragen | 1245 | ||
35.4 Neue Autoinkrementwerte abrufen | 1250 | ||
Kapitel 36 | 1252 | ||
Stark typisierte DataSets | 1252 | ||
36.1 Ein stark typisiertes DataSet erzeugen | 1252 | ||
36.1.1 Typisierte DataSets mit dem Visual Studio Designer erstellen | 1252 | ||
36.1.2 Das Kommandozeilentool XSD.exe | 1255 | ||
36.2 Die Anatomie eines typisierten DataSets | 1256 | ||
36.2.1 Die Datenzeilen einer Tabelle ausgeben | 1256 | ||
36.2.2 Datenzeilen hinzufügen | 1259 | ||
36.2.3 Datenzeilen bearbeiten | 1260 | ||
36.2.4 Datenzeilen suchen | 1260 | ||
36.2.5 NULL-Werte im typisierten DataSet | 1261 | ||
36.2.6 Die Daten in einem hierarchischen DataSet | 1261 | ||
36.3 Typisierte DataSets manuell im Designer erzeugen | 1262 | ||
36.3.1 Eine »DataTable« manuell erzeugen | 1262 | ||
36.3.2 Der »DataTable« Spalten hinzufügen | 1263 | ||
36.3.3 Beziehungen zwischen den Tabellen erstellen | 1263 | ||
36.4 Weiter gehende Betrachtungen | 1265 | ||
36.5 Der »TableAdapter« | 1265 | ||
36.5.1 Einen »TableAdapter« mit Visual Studio erzeugen | 1265 | ||
36.5.2 Die Methode »Fill« des »TableAdapters« | 1270 | ||
36.5.3 Die Methode »GetData« | 1271 | ||
36.5.4 Die Methode »Update« | 1271 | ||
36.5.5 Aktualisieren mit den DBDirect-Methoden | 1271 | ||
36.5.6 TableAdapter mit mehreren Abfragen | 1272 | ||
36.5.7 Änderungen an einem »TableAdapter« vornehmen | 1275 | ||
36.6 Fazit: Typisierte oder nicht typisierte DataSets? | 1276 | ||
Kapitel 37 | 1278 | ||
Einführung in das ADO.NET Entity Framework | 1278 | ||
37.1 Kritische Betrachtung von ADO.NET | 1278 | ||
37.2 Ein erstes Entity Data Model (EDM) erstellen | 1280 | ||
37.3 Das Entity Data Model im Designer | 1284 | ||
37.3.1 Die übergeordneten Eigenschaften einer Entität | 1284 | ||
37.3.2 Eigenschaften eines Entitätsobjekts | 1285 | ||
37.3.3 Assoziationen im Entity Data Model | 1288 | ||
37.3.4 Der Kontext der Entitäten | 1289 | ||
37.4 Der Aufbau des Entity Data Models | 1290 | ||
37.5 Die Klassen des Entity Data Models (EDM) | 1293 | ||
37.5.1 Die Entitätsklassen | 1294 | ||
37.5.2 Der ObjectContext | 1297 | ||
37.6 Die Architektur des Entity Frameworks | 1298 | ||
37.6.1 Object Services | 1299 | ||
37.6.2 Die Schichten des Entity Frameworks | 1299 | ||
Kapitel 38 | 1302 | ||
Datenabfragen des Entity Data Models (EDM) | 1302 | ||
38.1 Abfragen mit LINQ to Entities | 1303 | ||
38.1.1 Allgemeine Begriffe in LINQ | 1303 | ||
38.1.2 Einfache Abfragen | 1303 | ||
38.1.3 Navigieren in Abfragen | 1310 | ||
38.1.4 Aggregatmethoden | 1315 | ||
38.1.5 Joins in LINQ definieren | 1316 | ||
38.1.6 In Beziehung stehende Daten laden | 1319 | ||
38.2 Abfragen mit Entity SQL | 1325 | ||
38.2.1 Ein erstes Beispiel mit Entity SQL | 1325 | ||
38.2.2 Die fundamentalen Regeln der Entity-SQL-Syntax | 1326 | ||
38.2.3 Filtern mit Entity SQL | 1327 | ||
38.2.4 Parametrisierte Abfragen | 1329 | ||
38.3 Der EntityClient-Provider | 1330 | ||
38.3.1 Verbindungen mit »EntityConnection« | 1331 | ||
38.3.2 Die Klasse »EntityCommand« | 1332 | ||
38.4 Abfrage-Generator-Methoden (QueryBuilder-Methoden) | 1333 | ||
38.5 SQL-Direktabfragen | 1334 | ||
Kapitel 39 | 1336 | ||
Entitätsaktualisierung und Zustandsverwaltung | 1336 | ||
39.1 Aktualisieren von Entitäten | 1336 | ||
39.1.1 Entitäten ändern | 1336 | ||
39.1.2 Hinzufügen neuer Entitäten | 1338 | ||
39.1.3 Löschen einer Entität | 1342 | ||
39.2 Der Lebenszyklus einer Entität im Objektkontext | 1345 | ||
39.2.1 Der Zustand einer Entität | 1345 | ||
39.2.2 Das Team der Objekte im Überblick | 1345 | ||
39.2.3 Neue Entitäten im Objektkontext | 1346 | ||
39.2.4 Die Zustände einer Entität | 1348 | ||
39.2.5 Zusätzliche Entitäten in den Datencache laden | 1350 | ||
39.2.6 Die Zustandsverfolgung mit »MergeOption« steuern | 1350 | ||
39.3 Das »ObjectStateEntry«-Objekt | 1353 | ||
39.3.1 Die Current- und Originalwerte abrufen | 1355 | ||
39.3.2 Die Methode »TryGetObjectStateEntry« | 1356 | ||
39.3.3 Abrufen bestimmter Gruppen | 1356 | ||
39.3.4 Die Methode »GetModifiedProperties« | 1357 | ||
39.4 Die Klasse »EntityKey« | 1358 | ||
39.4.1 Die Methoden »GetObjectByKey« und »TryGetObjectByKey« | 1358 | ||
39.5 Komplexere Szenarien | 1359 | ||
39.5.1 Die Methode »ChangeState« | 1360 | ||
39.5.2 Die Methoden »ApplyCurrentChanges« und »ApplyOriginalChanges« | 1361 | ||
Kapitel 40 | 1364 | ||
Konflikte behandeln | 1364 | ||
40.1 Allgemeine Betrachtungen | 1364 | ||
40.1.1 Das pessimistische Sperren | 1365 | ||
40.1.2 Das optimistische Sperren | 1365 | ||
40.2 Konkurrierende Zugriffe mit dem Entity Framework | 1366 | ||
40.2.1 Das Standardverhalten des Entity Frameworks | 1366 | ||
40.2.2 Das Aktualisierungsverhalten mit »Fixed« beeinflussen | 1367 | ||
40.2.3 Auf die Ausnahme »OptimisticConcurrencyException« reagieren | 1368 | ||
40.2.4 Das »ClientWins«-Szenario | 1369 | ||
40.2.5 Das »StoreWins«-Szenario | 1371 | ||
Kapitel 41 | 1372 | ||
Plain Old CLR Objects (POCOs) | 1372 | ||
41.1 Ein erstes Projekt mit POCO-Klassen | 1372 | ||
41.1.1 Erstellen einfacher POCO-Klassen | 1372 | ||
41.1.2 Erstellen des Objektkontextes | 1374 | ||
41.2 Datenabfrage mit Hilfe der POCOs | 1376 | ||
41.2.1 In Beziehung stehende Daten laden | 1376 | ||
41.3 Änderungen verfolgen | 1378 | ||
41.3.1 Die Methode »DetectChanges« | 1378 | ||
41.3.2 In Beziehung stehende POCOs aktualisieren | 1380 | ||
Index | 1386 |